binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2015 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/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or1k.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/visium.h"
 152 #include "elf/x86-64.h"
 153 #include "elf/xc16x.h"
 154 #include "elf/xgate.h"
 155 #include "elf/xstormy16.h"
 156 #include "elf/xtensa.h"
 157
 158 #include "getopt.h"
 159 #include "libiberty.h"
 160 #include "safe-ctype.h"
 161 #include "filenames.h"
 162
 163 #ifndef offsetof
 164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 165 #endif
 166
 167 char * program_name = "readelf";
 168 static unsigned long archive_file_offset;
 169 static unsigned long archive_file_size;
 170 static bfd_size_type current_file_size;
 171 static unsigned long dynamic_addr;
 172 static bfd_size_type dynamic_size;
 173 static size_t dynamic_nent;
 174 static char * dynamic_strings;
 175 static unsigned long dynamic_strings_length;
 176 static char * string_table;
 177 static unsigned long string_table_length;
 178 static unsigned long num_dynamic_syms;
 179 static Elf_Internal_Sym * dynamic_symbols;
 180 static Elf_Internal_Syminfo * dynamic_syminfo;
 181 static unsigned long dynamic_syminfo_offset;
 182 static unsigned int dynamic_syminfo_nent;
 183 static char program_interpreter[PATH_MAX];
 184 static bfd_vma dynamic_info[DT_ENCODING];
 185 static bfd_vma dynamic_info_DT_GNU_HASH;
 186 static bfd_vma version_info[16];
 187 static Elf_Internal_Ehdr elf_header;
 188 static Elf_Internal_Shdr * section_headers;
 189 static Elf_Internal_Phdr * program_headers;
 190 static Elf_Internal_Dyn *  dynamic_section;
 191 static Elf_Internal_Shdr * symtab_shndx_hdr;
 192 static int show_name;
 193 static int do_dynamic;
 194 static int do_syms;
 195 static int do_dyn_syms;
 196 static int do_reloc;
 197 static int do_sections;
 198 static int do_section_groups;
 199 static int do_section_details;
 200 static int do_segments;
 201 static int do_unwind;
 202 static int do_using_dynamic;
 203 static int do_header;
 204 static int do_dump;
 205 static int do_version;
 206 static int do_histogram;
 207 static int do_debugging;
 208 static int do_arch;
 209 static int do_notes;
 210 static int do_archive_index;
 211 static int is_32bit_elf;
 212
 213 struct group_list
 214 {
 215   struct group_list * next;
 216   unsigned int section_index;
 217 };
 218
 219 struct group
 220 {
 221   struct group_list * root;
 222   unsigned int group_index;
 223 };
 224
 225 static size_t group_count;
 226 static struct group * section_groups;
 227 static struct group ** section_headers_groups;
 228
 229
 230 /* Flag bits indicating particular types of dump.  */
 231 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 232 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 233 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 234 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 235 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 236
 237 typedef unsigned char dump_type;
 238
 239 /* A linked list of the section names for which dumps were requested.  */
 240 struct dump_list_entry
 241 {
 242   char * name;
 243   dump_type type;
 244   struct dump_list_entry * next;
 245 };
 246 static struct dump_list_entry * dump_sects_byname;
 247
 248 /* A dynamic array of flags indicating for which sections a dump
 249    has been requested via command line switches.  */
 250 static dump_type *   cmdline_dump_sects = NULL;
 251 static unsigned int  num_cmdline_dump_sects = 0;
 252
 253 /* A dynamic array of flags indicating for which sections a dump of
 254    some kind has been requested.  It is reset on a per-object file
 255    basis and then initialised from the cmdline_dump_sects array,
 256    the results of interpreting the -w switch, and the
 257    dump_sects_byname list.  */
 258 static dump_type *   dump_sects = NULL;
 259 static unsigned int  num_dump_sects = 0;
 260
 261
 262 /* How to print a vma value.  */
 263 typedef enum print_mode
 264 {
 265   HEX,
 266   DEC,
 267   DEC_5,
 268   UNSIGNED,
 269   PREFIX_HEX,
 270   FULL_HEX,
 271   LONG_HEX
 272 }
 273 print_mode;
 274
 275 /* Versioned symbol info.  */
 276 enum versioned_symbol_info
 277 {
 278   symbol_undefined,
 279   symbol_hidden,
 280   symbol_public
 281 };
 282
 283 static const char *get_symbol_version_string
 284   (FILE *file, int is_dynsym, const char *strtab,
 285    unsigned long int strtab_size, unsigned int si,
 286    Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
 287    unsigned short *vna_other);
 288
 289 #define UNKNOWN -1
 290
 291 #define SECTION_NAME(X)                                         \
 292   ((X) == NULL ? _("<none>")                                    \
 293    : string_table == NULL ? _("<no-name>")                      \
 294    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 295   : string_table + (X)->sh_name))
 296
 297 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 298
 299 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 300   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 301    : get_64bit_elf_symbols (file, section, sym_count))
 302
 303 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 305    already been called and verified that the string exists.  */
 306 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 307
 308 #define REMOVE_ARCH_BITS(ADDR)                  \
 309   do                                            \
 310     {                                           \
 311       if (elf_header.e_machine == EM_ARM)       \
 312         (ADDR) &= ~1;                           \
 313     }                                           \
 314   while (0)
 315 \f
 316 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 317    the offset of the current archive member, if we are examining an archive.
 318    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 319    using malloc and fill that.  In either case return the pointer to the start of
 320    the retrieved data or NULL if something went wrong.  If something does go wrong
 321    and REASON is not NULL then emit an error message using REASON as part of the
 322    context.  */
 323
 324 static void *
 325 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 326           bfd_size_type nmemb, const char * reason)
 327 {
 328   void * mvar;
 329   bfd_size_type amt = size * nmemb;
 330
 331   if (size == 0 || nmemb == 0)
 332     return NULL;
 333
 334   /* If the size_t type is smaller than the bfd_size_type, eg because
 335      you are building a 32-bit tool on a 64-bit host, then make sure
 336      that when the sizes are cast to (size_t) no information is lost.  */
 337   if (sizeof (size_t) < sizeof (bfd_size_type)
 338       && (   (bfd_size_type) ((size_t) size) != size
 339           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 340     {
 341       if (reason)
 342         error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 343                (unsigned long long) nmemb, (unsigned long long) size, reason);
 344       return NULL;
 345     }
 346
 347   /* Check for size overflow.  */
 348   if (amt < nmemb)
 349     {
 350       if (reason)
 351         error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 352                (unsigned long long) nmemb, (unsigned long long) size, reason);
 353       return NULL;
 354     }
 355
 356   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 357      attempting to allocate memory when the read is bound to fail.  */
 358   if (amt > current_file_size
 359       || offset + archive_file_offset + amt > current_file_size)
 360     {
 361       if (reason)
 362         error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
 363                (unsigned long long) amt, reason);
 364       return NULL;
 365     }
 366
 367   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 368     {
 369       if (reason)
 370         error (_("Unable to seek to 0x%lx for %s\n"),
 371                (unsigned long) archive_file_offset + offset, reason);
 372       return NULL;
 373     }
 374
 375   mvar = var;
 376   if (mvar == NULL)
 377     {
 378       /* Check for overflow.  */
 379       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 380         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 381         mvar = malloc ((size_t) amt + 1);
 382
 383       if (mvar == NULL)
 384         {
 385           if (reason)
 386             error (_("Out of memory allocating 0x%llx bytes for %s\n"),
 387                    (unsigned long long) amt, reason);
 388           return NULL;
 389         }
 390
 391       ((char *) mvar)[amt] = '\0';
 392     }
 393
 394   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 395     {
 396       if (reason)
 397         error (_("Unable to read in 0x%llx bytes of %s\n"),
 398                (unsigned long long) amt, reason);
 399       if (mvar != var)
 400         free (mvar);
 401       return NULL;
 402     }
 403
 404   return mvar;
 405 }
 406
 407 /* Print a VMA value.  */
 408
 409 static int
 410 print_vma (bfd_vma vma, print_mode mode)
 411 {
 412   int nc = 0;
 413
 414   switch (mode)
 415     {
 416     case FULL_HEX:
 417       nc = printf ("0x");
 418       /* Drop through.  */
 419
 420     case LONG_HEX:
 421 #ifdef BFD64
 422       if (is_32bit_elf)
 423         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 424 #endif
 425       printf_vma (vma);
 426       return nc + 16;
 427
 428     case DEC_5:
 429       if (vma <= 99999)
 430         return printf ("%5" BFD_VMA_FMT "d", vma);
 431       /* Drop through.  */
 432
 433     case PREFIX_HEX:
 434       nc = printf ("0x");
 435       /* Drop through.  */
 436
 437     case HEX:
 438       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 439
 440     case DEC:
 441       return printf ("%" BFD_VMA_FMT "d", vma);
 442
 443     case UNSIGNED:
 444       return printf ("%" BFD_VMA_FMT "u", vma);
 445     }
 446   return 0;
 447 }
 448
 449 /* Display a symbol on stdout.  Handles the display of control characters and
 450    multibye characters (assuming the host environment supports them).
 451
 452    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 453
 454    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 455    padding as necessary.
 456
 457    Returns the number of emitted characters.  */
 458
 459 static unsigned int
 460 print_symbol (int width, const char *symbol)
 461 {
 462   bfd_boolean extra_padding = FALSE;
 463   int num_printed = 0;
 464 #ifdef HAVE_MBSTATE_T
 465   mbstate_t state;
 466 #endif
 467   int width_remaining;
 468
 469   if (width < 0)
 470     {
 471       /* Keep the width positive.  This also helps.  */
 472       width = - width;
 473       extra_padding = TRUE;
 474     }
 475   assert (width != 0);
 476
 477   if (do_wide)
 478     /* Set the remaining width to a very large value.
 479        This simplifies the code below.  */
 480     width_remaining = INT_MAX;
 481   else
 482     width_remaining = width;
 483
 484 #ifdef HAVE_MBSTATE_T
 485   /* Initialise the multibyte conversion state.  */
 486   memset (& state, 0, sizeof (state));
 487 #endif
 488
 489   while (width_remaining)
 490     {
 491       size_t  n;
 492       const char c = *symbol++;
 493
 494       if (c == 0)
 495         break;
 496
 497       /* Do not print control characters directly as they can affect terminal
 498          settings.  Such characters usually appear in the names generated
 499          by the assembler for local labels.  */
 500       if (ISCNTRL (c))
 501         {
 502           if (width_remaining < 2)
 503             break;
 504
 505           printf ("^%c", c + 0x40);
 506           width_remaining -= 2;
 507           num_printed += 2;
 508         }
 509       else if (ISPRINT (c))
 510         {
 511           putchar (c);
 512           width_remaining --;
 513           num_printed ++;
 514         }
 515       else
 516         {
 517 #ifdef HAVE_MBSTATE_T
 518           wchar_t w;
 519 #endif
 520           /* Let printf do the hard work of displaying multibyte characters.  */
 521           printf ("%.1s", symbol - 1);
 522           width_remaining --;
 523           num_printed ++;
 524
 525 #ifdef HAVE_MBSTATE_T
 526           /* Try to find out how many bytes made up the character that was
 527              just printed.  Advance the symbol pointer past the bytes that
 528              were displayed.  */
 529           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 530 #else
 531           n = 1;
 532 #endif
 533           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 534             symbol += (n - 1);
 535         }
 536     }
 537
 538   if (extra_padding && num_printed < width)
 539     {
 540       /* Fill in the remaining spaces.  */
 541       printf ("%-*s", width - num_printed, " ");
 542       num_printed = width;
 543     }
 544
 545   return num_printed;
 546 }
 547
 548 /* Returns a pointer to a static buffer containing a  printable version of
 549    the given section's name.  Like print_symbol, except that it does not try
 550    to print multibyte characters, it just interprets them as hex values.  */
 551
 552 static const char *
 553 printable_section_name (const Elf_Internal_Shdr * sec)
 554 {
 555 #define MAX_PRINT_SEC_NAME_LEN 128
 556   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 557   const char * name = SECTION_NAME (sec);
 558   char *       buf = sec_name_buf;
 559   char         c;
 560   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 561
 562   while ((c = * name ++) != 0)
 563     {
 564       if (ISCNTRL (c))
 565         {
 566           if (remaining < 2)
 567             break;
 568
 569           * buf ++ = '^';
 570           * buf ++ = c + 0x40;
 571           remaining -= 2;
 572         }
 573       else if (ISPRINT (c))
 574         {
 575           * buf ++ = c;
 576           remaining -= 1;
 577         }
 578       else
 579         {
 580           static char hex[17] = "0123456789ABCDEF";
 581
 582           if (remaining < 4)
 583             break;
 584           * buf ++ = '<';
 585           * buf ++ = hex[(c & 0xf0) >> 4];
 586           * buf ++ = hex[c & 0x0f];
 587           * buf ++ = '>';
 588           remaining -= 4;
 589         }
 590
 591       if (remaining == 0)
 592         break;
 593     }
 594
 595   * buf = 0;
 596   return sec_name_buf;
 597 }
 598
 599 static const char *
 600 printable_section_name_from_index (unsigned long ndx)
 601 {
 602   if (ndx >= elf_header.e_shnum)
 603     return _("<corrupt>");
 604
 605   return printable_section_name (section_headers + ndx);
 606 }
 607
 608 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 609
 610 static Elf_Internal_Shdr *
 611 find_section (const char * name)
 612 {
 613   unsigned int i;
 614
 615   for (i = 0; i < elf_header.e_shnum; i++)
 616     if (streq (SECTION_NAME (section_headers + i), name))
 617       return section_headers + i;
 618
 619   return NULL;
 620 }
 621
 622 /* Return a pointer to a section containing ADDR, or NULL if no such
 623    section exists.  */
 624
 625 static Elf_Internal_Shdr *
 626 find_section_by_address (bfd_vma addr)
 627 {
 628   unsigned int i;
 629
 630   for (i = 0; i < elf_header.e_shnum; i++)
 631     {
 632       Elf_Internal_Shdr *sec = section_headers + i;
 633       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 634         return sec;
 635     }
 636
 637   return NULL;
 638 }
 639
 640 static Elf_Internal_Shdr *
 641 find_section_by_type (unsigned int type)
 642 {
 643   unsigned int i;
 644
 645   for (i = 0; i < elf_header.e_shnum; i++)
 646     {
 647       Elf_Internal_Shdr *sec = section_headers + i;
 648       if (sec->sh_type == type)
 649         return sec;
 650     }
 651
 652   return NULL;
 653 }
 654
 655 /* Return a pointer to section NAME, or NULL if no such section exists,
 656    restricted to the list of sections given in SET.  */
 657
 658 static Elf_Internal_Shdr *
 659 find_section_in_set (const char * name, unsigned int * set)
 660 {
 661   unsigned int i;
 662
 663   if (set != NULL)
 664     {
 665       while ((i = *set++) > 0)
 666         if (streq (SECTION_NAME (section_headers + i), name))
 667           return section_headers + i;
 668     }
 669
 670   return find_section (name);
 671 }
 672
 673 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 674    bytes read.  */
 675
 676 static inline unsigned long
 677 read_uleb128 (unsigned char *data,
 678               unsigned int *length_return,
 679               const unsigned char * const end)
 680 {
 681   return read_leb128 (data, length_return, FALSE, end);
 682 }
 683
 684 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 685    This OS has so many departures from the ELF standard that we test it at
 686    many places.  */
 687
 688 static inline int
 689 is_ia64_vms (void)
 690 {
 691   return elf_header.e_machine == EM_IA_64
 692     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 693 }
 694
 695 /* Guess the relocation size commonly used by the specific machines.  */
 696
 697 static int
 698 guess_is_rela (unsigned int e_machine)
 699 {
 700   switch (e_machine)
 701     {
 702       /* Targets that use REL relocations.  */
 703     case EM_386:
 704     case EM_486:
 705     case EM_960:
 706     case EM_ARM:
 707     case EM_D10V:
 708     case EM_CYGNUS_D10V:
 709     case EM_DLX:
 710     case EM_MIPS:
 711     case EM_MIPS_RS3_LE:
 712     case EM_CYGNUS_M32R:
 713     case EM_SCORE:
 714     case EM_XGATE:
 715       return FALSE;
 716
 717       /* Targets that use RELA relocations.  */
 718     case EM_68K:
 719     case EM_860:
 720     case EM_AARCH64:
 721     case EM_ADAPTEVA_EPIPHANY:
 722     case EM_ALPHA:
 723     case EM_ALTERA_NIOS2:
 724     case EM_AVR:
 725     case EM_AVR_OLD:
 726     case EM_BLACKFIN:
 727     case EM_CR16:
 728     case EM_CRIS:
 729     case EM_CRX:
 730     case EM_D30V:
 731     case EM_CYGNUS_D30V:
 732     case EM_FR30:
 733     case EM_FT32:
 734     case EM_CYGNUS_FR30:
 735     case EM_CYGNUS_FRV:
 736     case EM_H8S:
 737     case EM_H8_300:
 738     case EM_H8_300H:
 739     case EM_IA_64:
 740     case EM_IP2K:
 741     case EM_IP2K_OLD:
 742     case EM_IQ2000:
 743     case EM_LATTICEMICO32:
 744     case EM_M32C_OLD:
 745     case EM_M32C:
 746     case EM_M32R:
 747     case EM_MCORE:
 748     case EM_CYGNUS_MEP:
 749     case EM_METAG:
 750     case EM_MMIX:
 751     case EM_MN10200:
 752     case EM_CYGNUS_MN10200:
 753     case EM_MN10300:
 754     case EM_CYGNUS_MN10300:
 755     case EM_MOXIE:
 756     case EM_MSP430:
 757     case EM_MSP430_OLD:
 758     case EM_MT:
 759     case EM_NDS32:
 760     case EM_NIOS32:
 761     case EM_OR1K:
 762     case EM_PPC64:
 763     case EM_PPC:
 764     case EM_RL78:
 765     case EM_RX:
 766     case EM_S390:
 767     case EM_S390_OLD:
 768     case EM_SH:
 769     case EM_SPARC:
 770     case EM_SPARC32PLUS:
 771     case EM_SPARCV9:
 772     case EM_SPU:
 773     case EM_TI_C6000:
 774     case EM_TILEGX:
 775     case EM_TILEPRO:
 776     case EM_V800:
 777     case EM_V850:
 778     case EM_CYGNUS_V850:
 779     case EM_VAX:
 780     case EM_VISIUM:
 781     case EM_X86_64:
 782     case EM_L1OM:
 783     case EM_K1OM:
 784     case EM_XSTORMY16:
 785     case EM_XTENSA:
 786     case EM_XTENSA_OLD:
 787     case EM_MICROBLAZE:
 788     case EM_MICROBLAZE_OLD:
 789       return TRUE;
 790
 791     case EM_68HC05:
 792     case EM_68HC08:
 793     case EM_68HC11:
 794     case EM_68HC16:
 795     case EM_FX66:
 796     case EM_ME16:
 797     case EM_MMA:
 798     case EM_NCPU:
 799     case EM_NDR1:
 800     case EM_PCP:
 801     case EM_ST100:
 802     case EM_ST19:
 803     case EM_ST7:
 804     case EM_ST9PLUS:
 805     case EM_STARCORE:
 806     case EM_SVX:
 807     case EM_TINYJ:
 808     default:
 809       warn (_("Don't know about relocations on this machine architecture\n"));
 810       return FALSE;
 811     }
 812 }
 813
 814 static int
 815 slurp_rela_relocs (FILE * file,
 816                    unsigned long rel_offset,
 817                    unsigned long rel_size,
 818                    Elf_Internal_Rela ** relasp,
 819                    unsigned long * nrelasp)
 820 {
 821   Elf_Internal_Rela * relas;
 822   size_t nrelas;
 823   unsigned int i;
 824
 825   if (is_32bit_elf)
 826     {
 827       Elf32_External_Rela * erelas;
 828
 829       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 830                                                  rel_size, _("32-bit relocation data"));
 831       if (!erelas)
 832         return 0;
 833
 834       nrelas = rel_size / sizeof (Elf32_External_Rela);
 835
 836       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 837                                              sizeof (Elf_Internal_Rela));
 838
 839       if (relas == NULL)
 840         {
 841           free (erelas);
 842           error (_("out of memory parsing relocs\n"));
 843           return 0;
 844         }
 845
 846       for (i = 0; i < nrelas; i++)
 847         {
 848           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 849           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 850           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 851         }
 852
 853       free (erelas);
 854     }
 855   else
 856     {
 857       Elf64_External_Rela * erelas;
 858
 859       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 860                                                  rel_size, _("64-bit relocation data"));
 861       if (!erelas)
 862         return 0;
 863
 864       nrelas = rel_size / sizeof (Elf64_External_Rela);
 865
 866       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 867                                              sizeof (Elf_Internal_Rela));
 868
 869       if (relas == NULL)
 870         {
 871           free (erelas);
 872           error (_("out of memory parsing relocs\n"));
 873           return 0;
 874         }
 875
 876       for (i = 0; i < nrelas; i++)
 877         {
 878           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 879           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 880           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 881
 882           /* The #ifdef BFD64 below is to prevent a compile time
 883              warning.  We know that if we do not have a 64 bit data
 884              type that we will never execute this code anyway.  */
 885 #ifdef BFD64
 886           if (elf_header.e_machine == EM_MIPS
 887               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 888             {
 889               /* In little-endian objects, r_info isn't really a
 890                  64-bit little-endian value: it has a 32-bit
 891                  little-endian symbol index followed by four
 892                  individual byte fields.  Reorder INFO
 893                  accordingly.  */
 894               bfd_vma inf = relas[i].r_info;
 895               inf = (((inf & 0xffffffff) << 32)
 896                       | ((inf >> 56) & 0xff)
 897                       | ((inf >> 40) & 0xff00)
 898                       | ((inf >> 24) & 0xff0000)
 899                       | ((inf >> 8) & 0xff000000));
 900               relas[i].r_info = inf;
 901             }
 902 #endif /* BFD64 */
 903         }
 904
 905       free (erelas);
 906     }
 907   *relasp = relas;
 908   *nrelasp = nrelas;
 909   return 1;
 910 }
 911
 912 static int
 913 slurp_rel_relocs (FILE * file,
 914                   unsigned long rel_offset,
 915                   unsigned long rel_size,
 916                   Elf_Internal_Rela ** relsp,
 917                   unsigned long * nrelsp)
 918 {
 919   Elf_Internal_Rela * rels;
 920   size_t nrels;
 921   unsigned int i;
 922
 923   if (is_32bit_elf)
 924     {
 925       Elf32_External_Rel * erels;
 926
 927       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 928                                                rel_size, _("32-bit relocation data"));
 929       if (!erels)
 930         return 0;
 931
 932       nrels = rel_size / sizeof (Elf32_External_Rel);
 933
 934       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 935
 936       if (rels == NULL)
 937         {
 938           free (erels);
 939           error (_("out of memory parsing relocs\n"));
 940           return 0;
 941         }
 942
 943       for (i = 0; i < nrels; i++)
 944         {
 945           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 946           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 947           rels[i].r_addend = 0;
 948         }
 949
 950       free (erels);
 951     }
 952   else
 953     {
 954       Elf64_External_Rel * erels;
 955
 956       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 957                                                rel_size, _("64-bit relocation data"));
 958       if (!erels)
 959         return 0;
 960
 961       nrels = rel_size / sizeof (Elf64_External_Rel);
 962
 963       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 964
 965       if (rels == NULL)
 966         {
 967           free (erels);
 968           error (_("out of memory parsing relocs\n"));
 969           return 0;
 970         }
 971
 972       for (i = 0; i < nrels; i++)
 973         {
 974           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 975           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 976           rels[i].r_addend = 0;
 977
 978           /* The #ifdef BFD64 below is to prevent a compile time
 979              warning.  We know that if we do not have a 64 bit data
 980              type that we will never execute this code anyway.  */
 981 #ifdef BFD64
 982           if (elf_header.e_machine == EM_MIPS
 983               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 984             {
 985               /* In little-endian objects, r_info isn't really a
 986                  64-bit little-endian value: it has a 32-bit
 987                  little-endian symbol index followed by four
 988                  individual byte fields.  Reorder INFO
 989                  accordingly.  */
 990               bfd_vma inf = rels[i].r_info;
 991               inf = (((inf & 0xffffffff) << 32)
 992                      | ((inf >> 56) & 0xff)
 993                      | ((inf >> 40) & 0xff00)
 994                      | ((inf >> 24) & 0xff0000)
 995                      | ((inf >> 8) & 0xff000000));
 996               rels[i].r_info = inf;
 997             }
 998 #endif /* BFD64 */
 999         }
1000
1001       free (erels);
1002     }
1003   *relsp = rels;
1004   *nrelsp = nrels;
1005   return 1;
1006 }
1007
1008 /* Returns the reloc type extracted from the reloc info field.  */
1009
1010 static unsigned int
1011 get_reloc_type (bfd_vma reloc_info)
1012 {
1013   if (is_32bit_elf)
1014     return ELF32_R_TYPE (reloc_info);
1015
1016   switch (elf_header.e_machine)
1017     {
1018     case EM_MIPS:
1019       /* Note: We assume that reloc_info has already been adjusted for us.  */
1020       return ELF64_MIPS_R_TYPE (reloc_info);
1021
1022     case EM_SPARCV9:
1023       return ELF64_R_TYPE_ID (reloc_info);
1024
1025     default:
1026       return ELF64_R_TYPE (reloc_info);
1027     }
1028 }
1029
1030 /* Return the symbol index extracted from the reloc info field.  */
1031
1032 static bfd_vma
1033 get_reloc_symindex (bfd_vma reloc_info)
1034 {
1035   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1036 }
1037
1038 static inline bfd_boolean
1039 uses_msp430x_relocs (void)
1040 {
1041   return
1042     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1043     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1044     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1045         /* TI compiler uses ELFOSABI_NONE.  */
1046         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1047 }
1048
1049 /* Display the contents of the relocation data found at the specified
1050    offset.  */
1051
1052 static void
1053 dump_relocations (FILE * file,
1054                   unsigned long rel_offset,
1055                   unsigned long rel_size,
1056                   Elf_Internal_Sym * symtab,
1057                   unsigned long nsyms,
1058                   char * strtab,
1059                   unsigned long strtablen,
1060                   int is_rela,
1061                   int is_dynsym)
1062 {
1063   unsigned int i;
1064   Elf_Internal_Rela * rels;
1065
1066   if (is_rela == UNKNOWN)
1067     is_rela = guess_is_rela (elf_header.e_machine);
1068
1069   if (is_rela)
1070     {
1071       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1072         return;
1073     }
1074   else
1075     {
1076       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1077         return;
1078     }
1079
1080   if (is_32bit_elf)
1081     {
1082       if (is_rela)
1083         {
1084           if (do_wide)
1085             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1086           else
1087             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1088         }
1089       else
1090         {
1091           if (do_wide)
1092             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1093           else
1094             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1095         }
1096     }
1097   else
1098     {
1099       if (is_rela)
1100         {
1101           if (do_wide)
1102             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1103           else
1104             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1105         }
1106       else
1107         {
1108           if (do_wide)
1109             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1110           else
1111             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1112         }
1113     }
1114
1115   for (i = 0; i < rel_size; i++)
1116     {
1117       const char * rtype;
1118       bfd_vma offset;
1119       bfd_vma inf;
1120       bfd_vma symtab_index;
1121       bfd_vma type;
1122
1123       offset = rels[i].r_offset;
1124       inf    = rels[i].r_info;
1125
1126       type = get_reloc_type (inf);
1127       symtab_index = get_reloc_symindex  (inf);
1128
1129       if (is_32bit_elf)
1130         {
1131           printf ("%8.8lx  %8.8lx ",
1132                   (unsigned long) offset & 0xffffffff,
1133                   (unsigned long) inf & 0xffffffff);
1134         }
1135       else
1136         {
1137 #if BFD_HOST_64BIT_LONG
1138           printf (do_wide
1139                   ? "%16.16lx  %16.16lx "
1140                   : "%12.12lx  %12.12lx ",
1141                   offset, inf);
1142 #elif BFD_HOST_64BIT_LONG_LONG
1143 #ifndef __MSVCRT__
1144           printf (do_wide
1145                   ? "%16.16llx  %16.16llx "
1146                   : "%12.12llx  %12.12llx ",
1147                   offset, inf);
1148 #else
1149           printf (do_wide
1150                   ? "%16.16I64x  %16.16I64x "
1151                   : "%12.12I64x  %12.12I64x ",
1152                   offset, inf);
1153 #endif
1154 #else
1155           printf (do_wide
1156                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1157                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1158                   _bfd_int64_high (offset),
1159                   _bfd_int64_low (offset),
1160                   _bfd_int64_high (inf),
1161                   _bfd_int64_low (inf));
1162 #endif
1163         }
1164
1165       switch (elf_header.e_machine)
1166         {
1167         default:
1168           rtype = NULL;
1169           break;
1170
1171         case EM_AARCH64:
1172           rtype = elf_aarch64_reloc_type (type);
1173           break;
1174
1175         case EM_M32R:
1176         case EM_CYGNUS_M32R:
1177           rtype = elf_m32r_reloc_type (type);
1178           break;
1179
1180         case EM_386:
1181         case EM_486:
1182           rtype = elf_i386_reloc_type (type);
1183           break;
1184
1185         case EM_68HC11:
1186         case EM_68HC12:
1187           rtype = elf_m68hc11_reloc_type (type);
1188           break;
1189
1190         case EM_68K:
1191           rtype = elf_m68k_reloc_type (type);
1192           break;
1193
1194         case EM_960:
1195           rtype = elf_i960_reloc_type (type);
1196           break;
1197
1198         case EM_AVR:
1199         case EM_AVR_OLD:
1200           rtype = elf_avr_reloc_type (type);
1201           break;
1202
1203         case EM_OLD_SPARCV9:
1204         case EM_SPARC32PLUS:
1205         case EM_SPARCV9:
1206         case EM_SPARC:
1207           rtype = elf_sparc_reloc_type (type);
1208           break;
1209
1210         case EM_SPU:
1211           rtype = elf_spu_reloc_type (type);
1212           break;
1213
1214         case EM_V800:
1215           rtype = v800_reloc_type (type);
1216           break;
1217         case EM_V850:
1218         case EM_CYGNUS_V850:
1219           rtype = v850_reloc_type (type);
1220           break;
1221
1222         case EM_D10V:
1223         case EM_CYGNUS_D10V:
1224           rtype = elf_d10v_reloc_type (type);
1225           break;
1226
1227         case EM_D30V:
1228         case EM_CYGNUS_D30V:
1229           rtype = elf_d30v_reloc_type (type);
1230           break;
1231
1232         case EM_DLX:
1233           rtype = elf_dlx_reloc_type (type);
1234           break;
1235
1236         case EM_SH:
1237           rtype = elf_sh_reloc_type (type);
1238           break;
1239
1240         case EM_MN10300:
1241         case EM_CYGNUS_MN10300:
1242           rtype = elf_mn10300_reloc_type (type);
1243           break;
1244
1245         case EM_MN10200:
1246         case EM_CYGNUS_MN10200:
1247           rtype = elf_mn10200_reloc_type (type);
1248           break;
1249
1250         case EM_FR30:
1251         case EM_CYGNUS_FR30:
1252           rtype = elf_fr30_reloc_type (type);
1253           break;
1254
1255         case EM_CYGNUS_FRV:
1256           rtype = elf_frv_reloc_type (type);
1257           break;
1258
1259         case EM_FT32:
1260           rtype = elf_ft32_reloc_type (type);
1261           break;
1262
1263         case EM_MCORE:
1264           rtype = elf_mcore_reloc_type (type);
1265           break;
1266
1267         case EM_MMIX:
1268           rtype = elf_mmix_reloc_type (type);
1269           break;
1270
1271         case EM_MOXIE:
1272           rtype = elf_moxie_reloc_type (type);
1273           break;
1274
1275         case EM_MSP430:
1276           if (uses_msp430x_relocs ())
1277             {
1278               rtype = elf_msp430x_reloc_type (type);
1279               break;
1280             }
1281         case EM_MSP430_OLD:
1282           rtype = elf_msp430_reloc_type (type);
1283           break;
1284
1285         case EM_NDS32:
1286           rtype = elf_nds32_reloc_type (type);
1287           break;
1288
1289         case EM_PPC:
1290           rtype = elf_ppc_reloc_type (type);
1291           break;
1292
1293         case EM_PPC64:
1294           rtype = elf_ppc64_reloc_type (type);
1295           break;
1296
1297         case EM_MIPS:
1298         case EM_MIPS_RS3_LE:
1299           rtype = elf_mips_reloc_type (type);
1300           break;
1301
1302         case EM_ALPHA:
1303           rtype = elf_alpha_reloc_type (type);
1304           break;
1305
1306         case EM_ARM:
1307           rtype = elf_arm_reloc_type (type);
1308           break;
1309
1310         case EM_ARC:
1311           rtype = elf_arc_reloc_type (type);
1312           break;
1313
1314         case EM_PARISC:
1315           rtype = elf_hppa_reloc_type (type);
1316           break;
1317
1318         case EM_H8_300:
1319         case EM_H8_300H:
1320         case EM_H8S:
1321           rtype = elf_h8_reloc_type (type);
1322           break;
1323
1324         case EM_OR1K:
1325           rtype = elf_or1k_reloc_type (type);
1326           break;
1327
1328         case EM_PJ:
1329         case EM_PJ_OLD:
1330           rtype = elf_pj_reloc_type (type);
1331           break;
1332         case EM_IA_64:
1333           rtype = elf_ia64_reloc_type (type);
1334           break;
1335
1336         case EM_CRIS:
1337           rtype = elf_cris_reloc_type (type);
1338           break;
1339
1340         case EM_860:
1341           rtype = elf_i860_reloc_type (type);
1342           break;
1343
1344         case EM_X86_64:
1345         case EM_L1OM:
1346         case EM_K1OM:
1347           rtype = elf_x86_64_reloc_type (type);
1348           break;
1349
1350         case EM_S370:
1351           rtype = i370_reloc_type (type);
1352           break;
1353
1354         case EM_S390_OLD:
1355         case EM_S390:
1356           rtype = elf_s390_reloc_type (type);
1357           break;
1358
1359         case EM_SCORE:
1360           rtype = elf_score_reloc_type (type);
1361           break;
1362
1363         case EM_XSTORMY16:
1364           rtype = elf_xstormy16_reloc_type (type);
1365           break;
1366
1367         case EM_CRX:
1368           rtype = elf_crx_reloc_type (type);
1369           break;
1370
1371         case EM_VAX:
1372           rtype = elf_vax_reloc_type (type);
1373           break;
1374
1375         case EM_VISIUM:
1376           rtype = elf_visium_reloc_type (type);
1377           break;
1378
1379         case EM_ADAPTEVA_EPIPHANY:
1380           rtype = elf_epiphany_reloc_type (type);
1381           break;
1382
1383         case EM_IP2K:
1384         case EM_IP2K_OLD:
1385           rtype = elf_ip2k_reloc_type (type);
1386           break;
1387
1388         case EM_IQ2000:
1389           rtype = elf_iq2000_reloc_type (type);
1390           break;
1391
1392         case EM_XTENSA_OLD:
1393         case EM_XTENSA:
1394           rtype = elf_xtensa_reloc_type (type);
1395           break;
1396
1397         case EM_LATTICEMICO32:
1398           rtype = elf_lm32_reloc_type (type);
1399           break;
1400
1401         case EM_M32C_OLD:
1402         case EM_M32C:
1403           rtype = elf_m32c_reloc_type (type);
1404           break;
1405
1406         case EM_MT:
1407           rtype = elf_mt_reloc_type (type);
1408           break;
1409
1410         case EM_BLACKFIN:
1411           rtype = elf_bfin_reloc_type (type);
1412           break;
1413
1414         case EM_CYGNUS_MEP:
1415           rtype = elf_mep_reloc_type (type);
1416           break;
1417
1418         case EM_CR16:
1419           rtype = elf_cr16_reloc_type (type);
1420           break;
1421
1422         case EM_MICROBLAZE:
1423         case EM_MICROBLAZE_OLD:
1424           rtype = elf_microblaze_reloc_type (type);
1425           break;
1426
1427         case EM_RL78:
1428           rtype = elf_rl78_reloc_type (type);
1429           break;
1430
1431         case EM_RX:
1432           rtype = elf_rx_reloc_type (type);
1433           break;
1434
1435         case EM_METAG:
1436           rtype = elf_metag_reloc_type (type);
1437           break;
1438
1439         case EM_XC16X:
1440         case EM_C166:
1441           rtype = elf_xc16x_reloc_type (type);
1442           break;
1443
1444         case EM_TI_C6000:
1445           rtype = elf_tic6x_reloc_type (type);
1446           break;
1447
1448         case EM_TILEGX:
1449           rtype = elf_tilegx_reloc_type (type);
1450           break;
1451
1452         case EM_TILEPRO:
1453           rtype = elf_tilepro_reloc_type (type);
1454           break;
1455
1456         case EM_XGATE:
1457           rtype = elf_xgate_reloc_type (type);
1458           break;
1459
1460         case EM_ALTERA_NIOS2:
1461           rtype = elf_nios2_reloc_type (type);
1462           break;
1463         }
1464
1465       if (rtype == NULL)
1466         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1467       else
1468         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1469
1470       if (elf_header.e_machine == EM_ALPHA
1471           && rtype != NULL
1472           && streq (rtype, "R_ALPHA_LITUSE")
1473           && is_rela)
1474         {
1475           switch (rels[i].r_addend)
1476             {
1477             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1478             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1479             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1480             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1481             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1482             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1483             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1484             default: rtype = NULL;
1485             }
1486           if (rtype)
1487             printf (" (%s)", rtype);
1488           else
1489             {
1490               putchar (' ');
1491               printf (_("<unknown addend: %lx>"),
1492                       (unsigned long) rels[i].r_addend);
1493             }
1494         }
1495       else if (symtab_index)
1496         {
1497           if (symtab == NULL || symtab_index >= nsyms)
1498             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1499           else
1500             {
1501               Elf_Internal_Sym * psym;
1502               const char * version_string;
1503               enum versioned_symbol_info sym_info;
1504               unsigned short vna_other;
1505
1506               psym = symtab + symtab_index;
1507
1508               version_string
1509                 = get_symbol_version_string (file, is_dynsym,
1510                                              strtab, strtablen,
1511                                              symtab_index,
1512                                              psym,
1513                                              &sym_info,
1514                                              &vna_other);
1515
1516               printf (" ");
1517
1518               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1519                 {
1520                   const char * name;
1521                   unsigned int len;
1522                   unsigned int width = is_32bit_elf ? 8 : 14;
1523
1524                   /* Relocations against GNU_IFUNC symbols do not use the value
1525                      of the symbol as the address to relocate against.  Instead
1526                      they invoke the function named by the symbol and use its
1527                      result as the address for relocation.
1528
1529                      To indicate this to the user, do not display the value of
1530                      the symbol in the "Symbols's Value" field.  Instead show
1531                      its name followed by () as a hint that the symbol is
1532                      invoked.  */
1533
1534                   if (strtab == NULL
1535                       || psym->st_name == 0
1536                       || psym->st_name >= strtablen)
1537                     name = "??";
1538                   else
1539                     name = strtab + psym->st_name;
1540
1541                   len = print_symbol (width, name);
1542                   if (version_string)
1543                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1544                             version_string);
1545                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1546                 }
1547               else
1548                 {
1549                   print_vma (psym->st_value, LONG_HEX);
1550
1551                   printf (is_32bit_elf ? "   " : " ");
1552                 }
1553
1554               if (psym->st_name == 0)
1555                 {
1556                   const char * sec_name = "<null>";
1557                   char name_buf[40];
1558
1559                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1560                     {
1561                       if (psym->st_shndx < elf_header.e_shnum)
1562                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1563                       else if (psym->st_shndx == SHN_ABS)
1564                         sec_name = "ABS";
1565                       else if (psym->st_shndx == SHN_COMMON)
1566                         sec_name = "COMMON";
1567                       else if ((elf_header.e_machine == EM_MIPS
1568                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1569                                || (elf_header.e_machine == EM_TI_C6000
1570                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1571                         sec_name = "SCOMMON";
1572                       else if (elf_header.e_machine == EM_MIPS
1573                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1574                         sec_name = "SUNDEF";
1575                       else if ((elf_header.e_machine == EM_X86_64
1576                                 || elf_header.e_machine == EM_L1OM
1577                                 || elf_header.e_machine == EM_K1OM)
1578                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1579                         sec_name = "LARGE_COMMON";
1580                       else if (elf_header.e_machine == EM_IA_64
1581                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1582                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1583                         sec_name = "ANSI_COM";
1584                       else if (is_ia64_vms ()
1585                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1586                         sec_name = "VMS_SYMVEC";
1587                       else
1588                         {
1589                           sprintf (name_buf, "<section 0x%x>",
1590                                    (unsigned int) psym->st_shndx);
1591                           sec_name = name_buf;
1592                         }
1593                     }
1594                   print_symbol (22, sec_name);
1595                 }
1596               else if (strtab == NULL)
1597                 printf (_("<string table index: %3ld>"), psym->st_name);
1598               else if (psym->st_name >= strtablen)
1599                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1600               else
1601                 {
1602                   print_symbol (22, strtab + psym->st_name);
1603                   if (version_string)
1604                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1605                             version_string);
1606                 }
1607
1608               if (is_rela)
1609                 {
1610                   bfd_signed_vma off = rels[i].r_addend;
1611
1612                   /* PR 17531: file: 2e63226f.  */
1613                   if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1614                     printf (" + %" BFD_VMA_FMT "x", off);
1615                   else if (off < 0)
1616                     printf (" - %" BFD_VMA_FMT "x", - off);
1617                   else
1618                     printf (" + %" BFD_VMA_FMT "x", off);
1619                 }
1620             }
1621         }
1622       else if (is_rela)
1623         {
1624           bfd_signed_vma off = rels[i].r_addend;
1625
1626           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1627           /* PR 17531: file: 2e63226f.  */
1628           if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1629             printf ("%" BFD_VMA_FMT "x", off);
1630           else if (off < 0)
1631             printf ("-%" BFD_VMA_FMT "x", - off);
1632           else
1633             printf ("%" BFD_VMA_FMT "x", off);
1634         }
1635
1636       if (elf_header.e_machine == EM_SPARCV9
1637           && rtype != NULL
1638           && streq (rtype, "R_SPARC_OLO10"))
1639         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1640
1641       putchar ('\n');
1642
1643 #ifdef BFD64
1644       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1645         {
1646           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1647           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1648           const char * rtype2 = elf_mips_reloc_type (type2);
1649           const char * rtype3 = elf_mips_reloc_type (type3);
1650
1651           printf ("                    Type2: ");
1652
1653           if (rtype2 == NULL)
1654             printf (_("unrecognized: %-7lx"),
1655                     (unsigned long) type2 & 0xffffffff);
1656           else
1657             printf ("%-17.17s", rtype2);
1658
1659           printf ("\n                    Type3: ");
1660
1661           if (rtype3 == NULL)
1662             printf (_("unrecognized: %-7lx"),
1663                     (unsigned long) type3 & 0xffffffff);
1664           else
1665             printf ("%-17.17s", rtype3);
1666
1667           putchar ('\n');
1668         }
1669 #endif /* BFD64 */
1670     }
1671
1672   free (rels);
1673 }
1674
1675 static const char *
1676 get_mips_dynamic_type (unsigned long type)
1677 {
1678   switch (type)
1679     {
1680     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1681     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1682     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1683     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1684     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1685     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1686     case DT_MIPS_MSYM: return "MIPS_MSYM";
1687     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1688     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1689     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1690     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1691     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1692     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1693     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1694     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1695     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1696     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1697     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1698     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1699     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1700     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1701     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1702     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1703     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1704     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1705     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1706     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1707     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1708     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1709     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1710     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1711     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1712     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1713     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1714     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1715     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1716     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1717     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1718     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1719     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1720     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1721     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1722     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1723     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1724     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1725     default:
1726       return NULL;
1727     }
1728 }
1729
1730 static const char *
1731 get_sparc64_dynamic_type (unsigned long type)
1732 {
1733   switch (type)
1734     {
1735     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1736     default:
1737       return NULL;
1738     }
1739 }
1740
1741 static const char *
1742 get_ppc_dynamic_type (unsigned long type)
1743 {
1744   switch (type)
1745     {
1746     case DT_PPC_GOT:    return "PPC_GOT";
1747     case DT_PPC_OPT:    return "PPC_OPT";
1748     default:
1749       return NULL;
1750     }
1751 }
1752
1753 static const char *
1754 get_ppc64_dynamic_type (unsigned long type)
1755 {
1756   switch (type)
1757     {
1758     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1759     case DT_PPC64_OPD:    return "PPC64_OPD";
1760     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1761     case DT_PPC64_OPT:    return "PPC64_OPT";
1762     default:
1763       return NULL;
1764     }
1765 }
1766
1767 static const char *
1768 get_parisc_dynamic_type (unsigned long type)
1769 {
1770   switch (type)
1771     {
1772     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1773     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1774     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1775     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1776     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1777     case DT_HP_PREINIT:         return "HP_PREINIT";
1778     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1779     case DT_HP_NEEDED:          return "HP_NEEDED";
1780     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1781     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1782     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1783     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1784     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1785     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1786     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1787     case DT_HP_FILTERED:        return "HP_FILTERED";
1788     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1789     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1790     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1791     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1792     case DT_PLT:                return "PLT";
1793     case DT_PLT_SIZE:           return "PLT_SIZE";
1794     case DT_DLT:                return "DLT";
1795     case DT_DLT_SIZE:           return "DLT_SIZE";
1796     default:
1797       return NULL;
1798     }
1799 }
1800
1801 static const char *
1802 get_ia64_dynamic_type (unsigned long type)
1803 {
1804   switch (type)
1805     {
1806     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1807     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1808     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1809     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1810     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1811     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1812     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1813     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1814     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1815     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1816     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1817     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1818     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1819     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1820     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1821     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1822     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1823     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1824     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1825     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1826     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1827     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1828     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1829     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1830     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1831     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1832     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1833     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1834     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1835     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1836     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1837     default:
1838       return NULL;
1839     }
1840 }
1841
1842 static const char *
1843 get_alpha_dynamic_type (unsigned long type)
1844 {
1845   switch (type)
1846     {
1847     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1848     default:
1849       return NULL;
1850     }
1851 }
1852
1853 static const char *
1854 get_score_dynamic_type (unsigned long type)
1855 {
1856   switch (type)
1857     {
1858     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1859     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1860     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1861     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1862     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1863     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1864     default:
1865       return NULL;
1866     }
1867 }
1868
1869 static const char *
1870 get_tic6x_dynamic_type (unsigned long type)
1871 {
1872   switch (type)
1873     {
1874     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1875     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1876     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1877     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1878     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1879     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1880     default:
1881       return NULL;
1882     }
1883 }
1884
1885 static const char *
1886 get_nios2_dynamic_type (unsigned long type)
1887 {
1888   switch (type)
1889     {
1890     case DT_NIOS2_GP: return "NIOS2_GP";
1891     default:
1892       return NULL;
1893     }
1894 }
1895
1896 static const char *
1897 get_dynamic_type (unsigned long type)
1898 {
1899   static char buff[64];
1900
1901   switch (type)
1902     {
1903     case DT_NULL:       return "NULL";
1904     case DT_NEEDED:     return "NEEDED";
1905     case DT_PLTRELSZ:   return "PLTRELSZ";
1906     case DT_PLTGOT:     return "PLTGOT";
1907     case DT_HASH:       return "HASH";
1908     case DT_STRTAB:     return "STRTAB";
1909     case DT_SYMTAB:     return "SYMTAB";
1910     case DT_RELA:       return "RELA";
1911     case DT_RELASZ:     return "RELASZ";
1912     case DT_RELAENT:    return "RELAENT";
1913     case DT_STRSZ:      return "STRSZ";
1914     case DT_SYMENT:     return "SYMENT";
1915     case DT_INIT:       return "INIT";
1916     case DT_FINI:       return "FINI";
1917     case DT_SONAME:     return "SONAME";
1918     case DT_RPATH:      return "RPATH";
1919     case DT_SYMBOLIC:   return "SYMBOLIC";
1920     case DT_REL:        return "REL";
1921     case DT_RELSZ:      return "RELSZ";
1922     case DT_RELENT:     return "RELENT";
1923     case DT_PLTREL:     return "PLTREL";
1924     case DT_DEBUG:      return "DEBUG";
1925     case DT_TEXTREL:    return "TEXTREL";
1926     case DT_JMPREL:     return "JMPREL";
1927     case DT_BIND_NOW:   return "BIND_NOW";
1928     case DT_INIT_ARRAY: return "INIT_ARRAY";
1929     case DT_FINI_ARRAY: return "FINI_ARRAY";
1930     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1931     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1932     case DT_RUNPATH:    return "RUNPATH";
1933     case DT_FLAGS:      return "FLAGS";
1934
1935     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1936     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1937
1938     case DT_CHECKSUM:   return "CHECKSUM";
1939     case DT_PLTPADSZ:   return "PLTPADSZ";
1940     case DT_MOVEENT:    return "MOVEENT";
1941     case DT_MOVESZ:     return "MOVESZ";
1942     case DT_FEATURE:    return "FEATURE";
1943     case DT_POSFLAG_1:  return "POSFLAG_1";
1944     case DT_SYMINSZ:    return "SYMINSZ";
1945     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1946
1947     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1948     case DT_CONFIG:     return "CONFIG";
1949     case DT_DEPAUDIT:   return "DEPAUDIT";
1950     case DT_AUDIT:      return "AUDIT";
1951     case DT_PLTPAD:     return "PLTPAD";
1952     case DT_MOVETAB:    return "MOVETAB";
1953     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1954
1955     case DT_VERSYM:     return "VERSYM";
1956
1957     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1958     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1959     case DT_RELACOUNT:  return "RELACOUNT";
1960     case DT_RELCOUNT:   return "RELCOUNT";
1961     case DT_FLAGS_1:    return "FLAGS_1";
1962     case DT_VERDEF:     return "VERDEF";
1963     case DT_VERDEFNUM:  return "VERDEFNUM";
1964     case DT_VERNEED:    return "VERNEED";
1965     case DT_VERNEEDNUM: return "VERNEEDNUM";
1966
1967     case DT_AUXILIARY:  return "AUXILIARY";
1968     case DT_USED:       return "USED";
1969     case DT_FILTER:     return "FILTER";
1970
1971     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1972     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1973     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1974     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1975     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1976     case DT_GNU_HASH:   return "GNU_HASH";
1977
1978     default:
1979       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1980         {
1981           const char * result;
1982
1983           switch (elf_header.e_machine)
1984             {
1985             case EM_MIPS:
1986             case EM_MIPS_RS3_LE:
1987               result = get_mips_dynamic_type (type);
1988               break;
1989             case EM_SPARCV9:
1990               result = get_sparc64_dynamic_type (type);
1991               break;
1992             case EM_PPC:
1993               result = get_ppc_dynamic_type (type);
1994               break;
1995             case EM_PPC64:
1996               result = get_ppc64_dynamic_type (type);
1997               break;
1998             case EM_IA_64:
1999               result = get_ia64_dynamic_type (type);
2000               break;
2001             case EM_ALPHA:
2002               result = get_alpha_dynamic_type (type);
2003               break;
2004             case EM_SCORE:
2005               result = get_score_dynamic_type (type);
2006               break;
2007             case EM_TI_C6000:
2008               result = get_tic6x_dynamic_type (type);
2009               break;
2010             case EM_ALTERA_NIOS2:
2011               result = get_nios2_dynamic_type (type);
2012               break;
2013             default:
2014               result = NULL;
2015               break;
2016             }
2017
2018           if (result != NULL)
2019             return result;
2020
2021           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2022         }
2023       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2024                || (elf_header.e_machine == EM_PARISC
2025                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2026         {
2027           const char * result;
2028
2029           switch (elf_header.e_machine)
2030             {
2031             case EM_PARISC:
2032               result = get_parisc_dynamic_type (type);
2033               break;
2034             case EM_IA_64:
2035               result = get_ia64_dynamic_type (type);
2036               break;
2037             default:
2038               result = NULL;
2039               break;
2040             }
2041
2042           if (result != NULL)
2043             return result;
2044
2045           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2046                     type);
2047         }
2048       else
2049         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2050
2051       return buff;
2052     }
2053 }
2054
2055 static char *
2056 get_file_type (unsigned e_type)
2057 {
2058   static char buff[32];
2059
2060   switch (e_type)
2061     {
2062     case ET_NONE:       return _("NONE (None)");
2063     case ET_REL:        return _("REL (Relocatable file)");
2064     case ET_EXEC:       return _("EXEC (Executable file)");
2065     case ET_DYN:        return _("DYN (Shared object file)");
2066     case ET_CORE:       return _("CORE (Core file)");
2067
2068     default:
2069       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2070         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2071       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2072         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2073       else
2074         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2075       return buff;
2076     }
2077 }
2078
2079 static char *
2080 get_machine_name (unsigned e_machine)
2081 {
2082   static char buff[64]; /* XXX */
2083
2084   switch (e_machine)
2085     {
2086     case EM_NONE:               return _("None");
2087     case EM_AARCH64:            return "AArch64";
2088     case EM_M32:                return "WE32100";
2089     case EM_SPARC:              return "Sparc";
2090     case EM_SPU:                return "SPU";
2091     case EM_386:                return "Intel 80386";
2092     case EM_68K:                return "MC68000";
2093     case EM_88K:                return "MC88000";
2094     case EM_486:                return "Intel 80486";
2095     case EM_860:                return "Intel 80860";
2096     case EM_MIPS:               return "MIPS R3000";
2097     case EM_S370:               return "IBM System/370";
2098     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2099     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2100     case EM_PARISC:             return "HPPA";
2101     case EM_PPC_OLD:            return "Power PC (old)";
2102     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2103     case EM_960:                return "Intel 90860";
2104     case EM_PPC:                return "PowerPC";
2105     case EM_PPC64:              return "PowerPC64";
2106     case EM_FR20:               return "Fujitsu FR20";
2107     case EM_FT32:               return "FTDI FT32";
2108     case EM_RH32:               return "TRW RH32";
2109     case EM_MCORE:              return "MCORE";
2110     case EM_ARM:                return "ARM";
2111     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2112     case EM_SH:                 return "Renesas / SuperH SH";
2113     case EM_SPARCV9:            return "Sparc v9";
2114     case EM_TRICORE:            return "Siemens Tricore";
2115     case EM_ARC:                return "ARC";
2116     case EM_H8_300:             return "Renesas H8/300";
2117     case EM_H8_300H:            return "Renesas H8/300H";
2118     case EM_H8S:                return "Renesas H8S";
2119     case EM_H8_500:             return "Renesas H8/500";
2120     case EM_IA_64:              return "Intel IA-64";
2121     case EM_MIPS_X:             return "Stanford MIPS-X";
2122     case EM_COLDFIRE:           return "Motorola Coldfire";
2123     case EM_ALPHA:              return "Alpha";
2124     case EM_CYGNUS_D10V:
2125     case EM_D10V:               return "d10v";
2126     case EM_CYGNUS_D30V:
2127     case EM_D30V:               return "d30v";
2128     case EM_CYGNUS_M32R:
2129     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2130     case EM_CYGNUS_V850:
2131     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2132     case EM_V850:               return "Renesas V850";
2133     case EM_CYGNUS_MN10300:
2134     case EM_MN10300:            return "mn10300";
2135     case EM_CYGNUS_MN10200:
2136     case EM_MN10200:            return "mn10200";
2137     case EM_MOXIE:              return "Moxie";
2138     case EM_CYGNUS_FR30:
2139     case EM_FR30:               return "Fujitsu FR30";
2140     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2141     case EM_PJ_OLD:
2142     case EM_PJ:                 return "picoJava";
2143     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2144     case EM_PCP:                return "Siemens PCP";
2145     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2146     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2147     case EM_STARCORE:           return "Motorola Star*Core processor";
2148     case EM_ME16:               return "Toyota ME16 processor";
2149     case EM_ST100:              return "STMicroelectronics ST100 processor";
2150     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2151     case EM_PDSP:               return "Sony DSP processor";
2152     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2153     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2154     case EM_FX66:               return "Siemens FX66 microcontroller";
2155     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2156     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2157     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2158     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2159     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2160     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2161     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2162     case EM_SVX:                return "Silicon Graphics SVx";
2163     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2164     case EM_VAX:                return "Digital VAX";
2165     case EM_VISIUM:             return "CDS VISIUMcore processor";
2166     case EM_AVR_OLD:
2167     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2168     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2169     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2170     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2171     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2172     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2173     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2174     case EM_PRISM:              return "Vitesse Prism";
2175     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2176     case EM_L1OM:               return "Intel L1OM";
2177     case EM_K1OM:               return "Intel K1OM";
2178     case EM_S390_OLD:
2179     case EM_S390:               return "IBM S/390";
2180     case EM_SCORE:              return "SUNPLUS S+Core";
2181     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2182     case EM_OR1K:               return "OpenRISC 1000";
2183     case EM_ARC_A5:             return "ARC International ARCompact processor";
2184     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2185     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2186     case EM_DLX:                return "OpenDLX";
2187     case EM_IP2K_OLD:
2188     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2189     case EM_IQ2000:             return "Vitesse IQ2000";
2190     case EM_XTENSA_OLD:
2191     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2192     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2193     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2194     case EM_NS32K:              return "National Semiconductor 32000 series";
2195     case EM_TPC:                return "Tenor Network TPC processor";
2196     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2197     case EM_MAX:                return "MAX Processor";
2198     case EM_CR:                 return "National Semiconductor CompactRISC";
2199     case EM_F2MC16:             return "Fujitsu F2MC16";
2200     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2201     case EM_LATTICEMICO32:      return "Lattice Mico32";
2202     case EM_M32C_OLD:
2203     case EM_M32C:               return "Renesas M32c";
2204     case EM_MT:                 return "Morpho Techologies MT processor";
2205     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2206     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2207     case EM_SEP:                return "Sharp embedded microprocessor";
2208     case EM_ARCA:               return "Arca RISC microprocessor";
2209     case EM_UNICORE:            return "Unicore";
2210     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2211     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2212     case EM_NIOS32:             return "Altera Nios";
2213     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2214     case EM_C166:
2215     case EM_XC16X:              return "Infineon Technologies xc16x";
2216     case EM_M16C:               return "Renesas M16C series microprocessors";
2217     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2218     case EM_CE:                 return "Freescale Communication Engine RISC core";
2219     case EM_TSK3000:            return "Altium TSK3000 core";
2220     case EM_RS08:               return "Freescale RS08 embedded processor";
2221     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2222     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2223     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2224     case EM_SE_C17:             return "Seiko Epson C17 family";
2225     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2226     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2227     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2228     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2229     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2230     case EM_R32C:               return "Renesas R32C series microprocessors";
2231     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2232     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2233     case EM_8051:               return "Intel 8051 and variants";
2234     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2235     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2236     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2237     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2238     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2239     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2240     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2241     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2242     case EM_CR16:
2243     case EM_MICROBLAZE:
2244     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2245     case EM_RL78:               return "Renesas RL78";
2246     case EM_RX:                 return "Renesas RX";
2247     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2248     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2249     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2250     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2251     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2252     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2253     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2254     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2255     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2256     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2257     case EM_CUDA:               return "NVIDIA CUDA architecture";
2258     case EM_XGATE:              return "Motorola XGATE embedded processor";
2259     default:
2260       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2261       return buff;
2262     }
2263 }
2264
2265 static void
2266 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2267 {
2268   unsigned eabi;
2269   int unknown = 0;
2270
2271   eabi = EF_ARM_EABI_VERSION (e_flags);
2272   e_flags &= ~ EF_ARM_EABIMASK;
2273
2274   /* Handle "generic" ARM flags.  */
2275   if (e_flags & EF_ARM_RELEXEC)
2276     {
2277       strcat (buf, ", relocatable executable");
2278       e_flags &= ~ EF_ARM_RELEXEC;
2279     }
2280
2281   /* Now handle EABI specific flags.  */
2282   switch (eabi)
2283     {
2284     default:
2285       strcat (buf, ", <unrecognized EABI>");
2286       if (e_flags)
2287         unknown = 1;
2288       break;
2289
2290     case EF_ARM_EABI_VER1:
2291       strcat (buf, ", Version1 EABI");
2292       while (e_flags)
2293         {
2294           unsigned flag;
2295
2296           /* Process flags one bit at a time.  */
2297           flag = e_flags & - e_flags;
2298           e_flags &= ~ flag;
2299
2300           switch (flag)
2301             {
2302             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2303               strcat (buf, ", sorted symbol tables");
2304               break;
2305
2306             default:
2307               unknown = 1;
2308               break;
2309             }
2310         }
2311       break;
2312
2313     case EF_ARM_EABI_VER2:
2314       strcat (buf, ", Version2 EABI");
2315       while (e_flags)
2316         {
2317           unsigned flag;
2318
2319           /* Process flags one bit at a time.  */
2320           flag = e_flags & - e_flags;
2321           e_flags &= ~ flag;
2322
2323           switch (flag)
2324             {
2325             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2326               strcat (buf, ", sorted symbol tables");
2327               break;
2328
2329             case EF_ARM_DYNSYMSUSESEGIDX:
2330               strcat (buf, ", dynamic symbols use segment index");
2331               break;
2332
2333             case EF_ARM_MAPSYMSFIRST:
2334               strcat (buf, ", mapping symbols precede others");
2335               break;
2336
2337             default:
2338               unknown = 1;
2339               break;
2340             }
2341         }
2342       break;
2343
2344     case EF_ARM_EABI_VER3:
2345       strcat (buf, ", Version3 EABI");
2346       break;
2347
2348     case EF_ARM_EABI_VER4:
2349       strcat (buf, ", Version4 EABI");
2350       while (e_flags)
2351         {
2352           unsigned flag;
2353
2354           /* Process flags one bit at a time.  */
2355           flag = e_flags & - e_flags;
2356           e_flags &= ~ flag;
2357
2358           switch (flag)
2359             {
2360             case EF_ARM_BE8:
2361               strcat (buf, ", BE8");
2362               break;
2363
2364             case EF_ARM_LE8:
2365               strcat (buf, ", LE8");
2366               break;
2367
2368             default:
2369               unknown = 1;
2370               break;
2371             }
2372       break;
2373         }
2374       break;
2375
2376     case EF_ARM_EABI_VER5:
2377       strcat (buf, ", Version5 EABI");
2378       while (e_flags)
2379         {
2380           unsigned flag;
2381
2382           /* Process flags one bit at a time.  */
2383           flag = e_flags & - e_flags;
2384           e_flags &= ~ flag;
2385
2386           switch (flag)
2387             {
2388             case EF_ARM_BE8:
2389               strcat (buf, ", BE8");
2390               break;
2391
2392             case EF_ARM_LE8:
2393               strcat (buf, ", LE8");
2394               break;
2395
2396             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2397               strcat (buf, ", soft-float ABI");
2398               break;
2399
2400             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2401               strcat (buf, ", hard-float ABI");
2402               break;
2403
2404             default:
2405               unknown = 1;
2406               break;
2407             }
2408         }
2409       break;
2410
2411     case EF_ARM_EABI_UNKNOWN:
2412       strcat (buf, ", GNU EABI");
2413       while (e_flags)
2414         {
2415           unsigned flag;
2416
2417           /* Process flags one bit at a time.  */
2418           flag = e_flags & - e_flags;
2419           e_flags &= ~ flag;
2420
2421           switch (flag)
2422             {
2423             case EF_ARM_INTERWORK:
2424               strcat (buf, ", interworking enabled");
2425               break;
2426
2427             case EF_ARM_APCS_26:
2428               strcat (buf, ", uses APCS/26");
2429               break;
2430
2431             case EF_ARM_APCS_FLOAT:
2432               strcat (buf, ", uses APCS/float");
2433               break;
2434
2435             case EF_ARM_PIC:
2436               strcat (buf, ", position independent");
2437               break;
2438
2439             case EF_ARM_ALIGN8:
2440               strcat (buf, ", 8 bit structure alignment");
2441               break;
2442
2443             case EF_ARM_NEW_ABI:
2444               strcat (buf, ", uses new ABI");
2445               break;
2446
2447             case EF_ARM_OLD_ABI:
2448               strcat (buf, ", uses old ABI");
2449               break;
2450
2451             case EF_ARM_SOFT_FLOAT:
2452               strcat (buf, ", software FP");
2453               break;
2454
2455             case EF_ARM_VFP_FLOAT:
2456               strcat (buf, ", VFP");
2457               break;
2458
2459             case EF_ARM_MAVERICK_FLOAT:
2460               strcat (buf, ", Maverick FP");
2461               break;
2462
2463             default:
2464               unknown = 1;
2465               break;
2466             }
2467         }
2468     }
2469
2470   if (unknown)
2471     strcat (buf,_(", <unknown>"));
2472 }
2473
2474 static void
2475 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2476 {
2477   --size; /* Leave space for null terminator.  */
2478
2479   switch (e_flags & EF_AVR_MACH)
2480     {
2481     case E_AVR_MACH_AVR1:
2482       strncat (buf, ", avr:1", size);
2483       break;
2484     case E_AVR_MACH_AVR2:
2485       strncat (buf, ", avr:2", size);
2486       break;
2487     case E_AVR_MACH_AVR25:
2488       strncat (buf, ", avr:25", size);
2489       break;
2490     case E_AVR_MACH_AVR3:
2491       strncat (buf, ", avr:3", size);
2492       break;
2493     case E_AVR_MACH_AVR31:
2494       strncat (buf, ", avr:31", size);
2495       break;
2496     case E_AVR_MACH_AVR35:
2497       strncat (buf, ", avr:35", size);
2498       break;
2499     case E_AVR_MACH_AVR4:
2500       strncat (buf, ", avr:4", size);
2501       break;
2502     case E_AVR_MACH_AVR5:
2503       strncat (buf, ", avr:5", size);
2504       break;
2505     case E_AVR_MACH_AVR51:
2506       strncat (buf, ", avr:51", size);
2507       break;
2508     case E_AVR_MACH_AVR6:
2509       strncat (buf, ", avr:6", size);
2510       break;
2511     case E_AVR_MACH_AVRTINY:
2512       strncat (buf, ", avr:100", size);
2513       break;
2514     case E_AVR_MACH_XMEGA1:
2515       strncat (buf, ", avr:101", size);
2516       break;
2517     case E_AVR_MACH_XMEGA2:
2518       strncat (buf, ", avr:102", size);
2519       break;
2520     case E_AVR_MACH_XMEGA3:
2521       strncat (buf, ", avr:103", size);
2522       break;
2523     case E_AVR_MACH_XMEGA4:
2524       strncat (buf, ", avr:104", size);
2525       break;
2526     case E_AVR_MACH_XMEGA5:
2527       strncat (buf, ", avr:105", size);
2528       break;
2529     case E_AVR_MACH_XMEGA6:
2530       strncat (buf, ", avr:106", size);
2531       break;
2532     case E_AVR_MACH_XMEGA7:
2533       strncat (buf, ", avr:107", size);
2534       break;
2535     default:
2536       strncat (buf, ", avr:<unknown>", size);
2537       break;
2538     }
2539
2540   size -= strlen (buf);
2541   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2542     strncat (buf, ", link-relax", size);
2543 }
2544
2545 static void
2546 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2547 {
2548   unsigned abi;
2549   unsigned arch;
2550   unsigned config;
2551   unsigned version;
2552   int has_fpu = 0;
2553   int r = 0;
2554
2555   static const char *ABI_STRINGS[] =
2556   {
2557     "ABI v0", /* use r5 as return register; only used in N1213HC */
2558     "ABI v1", /* use r0 as return register */
2559     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2560     "ABI v2fp", /* for FPU */
2561     "AABI",
2562     "ABI2 FP+"
2563   };
2564   static const char *VER_STRINGS[] =
2565   {
2566     "Andes ELF V1.3 or older",
2567     "Andes ELF V1.3.1",
2568     "Andes ELF V1.4"
2569   };
2570   static const char *ARCH_STRINGS[] =
2571   {
2572     "",
2573     "Andes Star v1.0",
2574     "Andes Star v2.0",
2575     "Andes Star v3.0",
2576     "Andes Star v3.0m"
2577   };
2578
2579   abi = EF_NDS_ABI & e_flags;
2580   arch = EF_NDS_ARCH & e_flags;
2581   config = EF_NDS_INST & e_flags;
2582   version = EF_NDS32_ELF_VERSION & e_flags;
2583
2584   memset (buf, 0, size);
2585
2586   switch (abi)
2587     {
2588     case E_NDS_ABI_V0:
2589     case E_NDS_ABI_V1:
2590     case E_NDS_ABI_V2:
2591     case E_NDS_ABI_V2FP:
2592     case E_NDS_ABI_AABI:
2593     case E_NDS_ABI_V2FP_PLUS:
2594       /* In case there are holes in the array.  */
2595       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2596       break;
2597
2598     default:
2599       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2600       break;
2601     }
2602
2603   switch (version)
2604     {
2605     case E_NDS32_ELF_VER_1_2:
2606     case E_NDS32_ELF_VER_1_3:
2607     case E_NDS32_ELF_VER_1_4:
2608       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2609       break;
2610
2611     default:
2612       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2613       break;
2614     }
2615
2616   if (E_NDS_ABI_V0 == abi)
2617     {
2618       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2619       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2620       if (arch == E_NDS_ARCH_STAR_V1_0)
2621         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2622       return;
2623     }
2624
2625   switch (arch)
2626     {
2627     case E_NDS_ARCH_STAR_V1_0:
2628     case E_NDS_ARCH_STAR_V2_0:
2629     case E_NDS_ARCH_STAR_V3_0:
2630     case E_NDS_ARCH_STAR_V3_M:
2631       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2632       break;
2633
2634     default:
2635       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2636       /* ARCH version determines how the e_flags are interpreted.
2637          If it is unknown, we cannot proceed.  */
2638       return;
2639     }
2640
2641   /* Newer ABI; Now handle architecture specific flags.  */
2642   if (arch == E_NDS_ARCH_STAR_V1_0)
2643     {
2644       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2645         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2646
2647       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2648         r += snprintf (buf + r, size -r, ", MAC");
2649
2650       if (config & E_NDS32_HAS_DIV_INST)
2651         r += snprintf (buf + r, size -r, ", DIV");
2652
2653       if (config & E_NDS32_HAS_16BIT_INST)
2654         r += snprintf (buf + r, size -r, ", 16b");
2655     }
2656   else
2657     {
2658       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2659         {
2660           if (version <= E_NDS32_ELF_VER_1_3)
2661             r += snprintf (buf + r, size -r, ", [B8]");
2662           else
2663             r += snprintf (buf + r, size -r, ", EX9");
2664         }
2665
2666       if (config & E_NDS32_HAS_MAC_DX_INST)
2667         r += snprintf (buf + r, size -r, ", MAC_DX");
2668
2669       if (config & E_NDS32_HAS_DIV_DX_INST)
2670         r += snprintf (buf + r, size -r, ", DIV_DX");
2671
2672       if (config & E_NDS32_HAS_16BIT_INST)
2673         {
2674           if (version <= E_NDS32_ELF_VER_1_3)
2675             r += snprintf (buf + r, size -r, ", 16b");
2676           else
2677             r += snprintf (buf + r, size -r, ", IFC");
2678         }
2679     }
2680
2681   if (config & E_NDS32_HAS_EXT_INST)
2682     r += snprintf (buf + r, size -r, ", PERF1");
2683
2684   if (config & E_NDS32_HAS_EXT2_INST)
2685     r += snprintf (buf + r, size -r, ", PERF2");
2686
2687   if (config & E_NDS32_HAS_FPU_INST)
2688     {
2689       has_fpu = 1;
2690       r += snprintf (buf + r, size -r, ", FPU_SP");
2691     }
2692
2693   if (config & E_NDS32_HAS_FPU_DP_INST)
2694     {
2695       has_fpu = 1;
2696       r += snprintf (buf + r, size -r, ", FPU_DP");
2697     }
2698
2699   if (config & E_NDS32_HAS_FPU_MAC_INST)
2700     {
2701       has_fpu = 1;
2702       r += snprintf (buf + r, size -r, ", FPU_MAC");
2703     }
2704
2705   if (has_fpu)
2706     {
2707       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2708         {
2709         case E_NDS32_FPU_REG_8SP_4DP:
2710           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2711           break;
2712         case E_NDS32_FPU_REG_16SP_8DP:
2713           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2714           break;
2715         case E_NDS32_FPU_REG_32SP_16DP:
2716           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2717           break;
2718         case E_NDS32_FPU_REG_32SP_32DP:
2719           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2720           break;
2721         }
2722     }
2723
2724   if (config & E_NDS32_HAS_AUDIO_INST)
2725     r += snprintf (buf + r, size -r, ", AUDIO");
2726
2727   if (config & E_NDS32_HAS_STRING_INST)
2728     r += snprintf (buf + r, size -r, ", STR");
2729
2730   if (config & E_NDS32_HAS_REDUCED_REGS)
2731     r += snprintf (buf + r, size -r, ", 16REG");
2732
2733   if (config & E_NDS32_HAS_VIDEO_INST)
2734     {
2735       if (version <= E_NDS32_ELF_VER_1_3)
2736         r += snprintf (buf + r, size -r, ", VIDEO");
2737       else
2738         r += snprintf (buf + r, size -r, ", SATURATION");
2739     }
2740
2741   if (config & E_NDS32_HAS_ENCRIPT_INST)
2742     r += snprintf (buf + r, size -r, ", ENCRP");
2743
2744   if (config & E_NDS32_HAS_L2C_INST)
2745     r += snprintf (buf + r, size -r, ", L2C");
2746 }
2747
2748 static char *
2749 get_machine_flags (unsigned e_flags, unsigned e_machine)
2750 {
2751   static char buf[1024];
2752
2753   buf[0] = '\0';
2754
2755   if (e_flags)
2756     {
2757       switch (e_machine)
2758         {
2759         default:
2760           break;
2761
2762         case EM_ARM:
2763           decode_ARM_machine_flags (e_flags, buf);
2764           break;
2765
2766         case EM_AVR:
2767           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2768           break;
2769
2770         case EM_BLACKFIN:
2771           if (e_flags & EF_BFIN_PIC)
2772             strcat (buf, ", PIC");
2773
2774           if (e_flags & EF_BFIN_FDPIC)
2775             strcat (buf, ", FDPIC");
2776
2777           if (e_flags & EF_BFIN_CODE_IN_L1)
2778             strcat (buf, ", code in L1");
2779
2780           if (e_flags & EF_BFIN_DATA_IN_L1)
2781             strcat (buf, ", data in L1");
2782
2783           break;
2784
2785         case EM_CYGNUS_FRV:
2786           switch (e_flags & EF_FRV_CPU_MASK)
2787             {
2788             case EF_FRV_CPU_GENERIC:
2789               break;
2790
2791             default:
2792               strcat (buf, ", fr???");
2793               break;
2794
2795             case EF_FRV_CPU_FR300:
2796               strcat (buf, ", fr300");
2797               break;
2798
2799             case EF_FRV_CPU_FR400:
2800               strcat (buf, ", fr400");
2801               break;
2802             case EF_FRV_CPU_FR405:
2803               strcat (buf, ", fr405");
2804               break;
2805
2806             case EF_FRV_CPU_FR450:
2807               strcat (buf, ", fr450");
2808               break;
2809
2810             case EF_FRV_CPU_FR500:
2811               strcat (buf, ", fr500");
2812               break;
2813             case EF_FRV_CPU_FR550:
2814               strcat (buf, ", fr550");
2815               break;
2816
2817             case EF_FRV_CPU_SIMPLE:
2818               strcat (buf, ", simple");
2819               break;
2820             case EF_FRV_CPU_TOMCAT:
2821               strcat (buf, ", tomcat");
2822               break;
2823             }
2824           break;
2825
2826         case EM_68K:
2827           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2828             strcat (buf, ", m68000");
2829           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2830             strcat (buf, ", cpu32");
2831           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2832             strcat (buf, ", fido_a");
2833           else
2834             {
2835               char const * isa = _("unknown");
2836               char const * mac = _("unknown mac");
2837               char const * additional = NULL;
2838
2839               switch (e_flags & EF_M68K_CF_ISA_MASK)
2840                 {
2841                 case EF_M68K_CF_ISA_A_NODIV:
2842                   isa = "A";
2843                   additional = ", nodiv";
2844                   break;
2845                 case EF_M68K_CF_ISA_A:
2846                   isa = "A";
2847                   break;
2848                 case EF_M68K_CF_ISA_A_PLUS:
2849                   isa = "A+";
2850                   break;
2851                 case EF_M68K_CF_ISA_B_NOUSP:
2852                   isa = "B";
2853                   additional = ", nousp";
2854                   break;
2855                 case EF_M68K_CF_ISA_B:
2856                   isa = "B";
2857                   break;
2858                 case EF_M68K_CF_ISA_C:
2859                   isa = "C";
2860                   break;
2861                 case EF_M68K_CF_ISA_C_NODIV:
2862                   isa = "C";
2863                   additional = ", nodiv";
2864                   break;
2865                 }
2866               strcat (buf, ", cf, isa ");
2867               strcat (buf, isa);
2868               if (additional)
2869                 strcat (buf, additional);
2870               if (e_flags & EF_M68K_CF_FLOAT)
2871                 strcat (buf, ", float");
2872               switch (e_flags & EF_M68K_CF_MAC_MASK)
2873                 {
2874                 case 0:
2875                   mac = NULL;
2876                   break;
2877                 case EF_M68K_CF_MAC:
2878                   mac = "mac";
2879                   break;
2880                 case EF_M68K_CF_EMAC:
2881                   mac = "emac";
2882                   break;
2883                 case EF_M68K_CF_EMAC_B:
2884                   mac = "emac_b";
2885                   break;
2886                 }
2887               if (mac)
2888                 {
2889                   strcat (buf, ", ");
2890                   strcat (buf, mac);
2891                 }
2892             }
2893           break;
2894
2895         case EM_CYGNUS_MEP:
2896           switch (e_flags & EF_MEP_CPU_MASK)
2897             {
2898             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2899             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2900             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2901             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2902             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2903             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2904             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2905             }
2906
2907           switch (e_flags & EF_MEP_COP_MASK)
2908             {
2909             case EF_MEP_COP_NONE: break;
2910             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2911             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2912             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2913             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2914             default: strcat (buf, _("<unknown MeP copro type>")); break;
2915             }
2916
2917           if (e_flags & EF_MEP_LIBRARY)
2918             strcat (buf, ", Built for Library");
2919
2920           if (e_flags & EF_MEP_INDEX_MASK)
2921             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2922                      e_flags & EF_MEP_INDEX_MASK);
2923
2924           if (e_flags & ~ EF_MEP_ALL_FLAGS)
2925             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2926                      e_flags & ~ EF_MEP_ALL_FLAGS);
2927           break;
2928
2929         case EM_PPC:
2930           if (e_flags & EF_PPC_EMB)
2931             strcat (buf, ", emb");
2932
2933           if (e_flags & EF_PPC_RELOCATABLE)
2934             strcat (buf, _(", relocatable"));
2935
2936           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2937             strcat (buf, _(", relocatable-lib"));
2938           break;
2939
2940         case EM_PPC64:
2941           if (e_flags & EF_PPC64_ABI)
2942             {
2943               char abi[] = ", abiv0";
2944
2945               abi[6] += e_flags & EF_PPC64_ABI;
2946               strcat (buf, abi);
2947             }
2948           break;
2949
2950         case EM_V800:
2951           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2952             strcat (buf, ", RH850 ABI");
2953
2954           if (e_flags & EF_V800_850E3)
2955             strcat (buf, ", V3 architecture");
2956
2957           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2958             strcat (buf, ", FPU not used");
2959
2960           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2961             strcat (buf, ", regmode: COMMON");
2962
2963           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2964             strcat (buf, ", r4 not used");
2965
2966           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2967             strcat (buf, ", r30 not used");
2968
2969           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2970             strcat (buf, ", r5 not used");
2971
2972           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2973             strcat (buf, ", r2 not used");
2974
2975           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2976             {
2977               switch (e_flags & - e_flags)
2978                 {
2979                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2980                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2981                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2982                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2983                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2984                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2985                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2986                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2987                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2988                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2989                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2990                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2991                 default: break;
2992                 }
2993             }
2994           break;
2995
2996         case EM_V850:
2997         case EM_CYGNUS_V850:
2998           switch (e_flags & EF_V850_ARCH)
2999             {
3000             case E_V850E3V5_ARCH:
3001               strcat (buf, ", v850e3v5");
3002               break;
3003             case E_V850E2V3_ARCH:
3004               strcat (buf, ", v850e2v3");
3005               break;
3006             case E_V850E2_ARCH:
3007               strcat (buf, ", v850e2");
3008               break;
3009             case E_V850E1_ARCH:
3010               strcat (buf, ", v850e1");
3011               break;
3012             case E_V850E_ARCH:
3013               strcat (buf, ", v850e");
3014               break;
3015             case E_V850_ARCH:
3016               strcat (buf, ", v850");
3017               break;
3018             default:
3019               strcat (buf, _(", unknown v850 architecture variant"));
3020               break;
3021             }
3022           break;
3023
3024         case EM_M32R:
3025         case EM_CYGNUS_M32R:
3026           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3027             strcat (buf, ", m32r");
3028           break;
3029
3030         case EM_MIPS:
3031         case EM_MIPS_RS3_LE:
3032           if (e_flags & EF_MIPS_NOREORDER)
3033             strcat (buf, ", noreorder");
3034
3035           if (e_flags & EF_MIPS_PIC)
3036             strcat (buf, ", pic");
3037
3038           if (e_flags & EF_MIPS_CPIC)
3039             strcat (buf, ", cpic");
3040
3041           if (e_flags & EF_MIPS_UCODE)
3042             strcat (buf, ", ugen_reserved");
3043
3044           if (e_flags & EF_MIPS_ABI2)
3045             strcat (buf, ", abi2");
3046
3047           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3048             strcat (buf, ", odk first");
3049
3050           if (e_flags & EF_MIPS_32BITMODE)
3051             strcat (buf, ", 32bitmode");
3052
3053           if (e_flags & EF_MIPS_NAN2008)
3054             strcat (buf, ", nan2008");
3055
3056           if (e_flags & EF_MIPS_FP64)
3057             strcat (buf, ", fp64");
3058
3059           switch ((e_flags & EF_MIPS_MACH))
3060             {
3061             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3062             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3063             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3064             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3065             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3066             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3067             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3068             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3069             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3070             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3071             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3072             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3073             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3074             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3075             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3076             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3077             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3078             case 0:
3079             /* We simply ignore the field in this case to avoid confusion:
3080                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3081                extension.  */
3082               break;
3083             default: strcat (buf, _(", unknown CPU")); break;
3084             }
3085
3086           switch ((e_flags & EF_MIPS_ABI))
3087             {
3088             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3089             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3090             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3091             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3092             case 0:
3093             /* We simply ignore the field in this case to avoid confusion:
3094                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3095                This means it is likely to be an o32 file, but not for
3096                sure.  */
3097               break;
3098             default: strcat (buf, _(", unknown ABI")); break;
3099             }
3100
3101           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3102             strcat (buf, ", mdmx");
3103
3104           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3105             strcat (buf, ", mips16");
3106
3107           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3108             strcat (buf, ", micromips");
3109
3110           switch ((e_flags & EF_MIPS_ARCH))
3111             {
3112             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3113             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3114             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3115             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3116             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3117             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3118             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3119             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3120             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3121             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3122             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3123             default: strcat (buf, _(", unknown ISA")); break;
3124             }
3125           break;
3126
3127         case EM_NDS32:
3128           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3129           break;
3130
3131         case EM_SH:
3132           switch ((e_flags & EF_SH_MACH_MASK))
3133             {
3134             case EF_SH1: strcat (buf, ", sh1"); break;
3135             case EF_SH2: strcat (buf, ", sh2"); break;
3136             case EF_SH3: strcat (buf, ", sh3"); break;
3137             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3138             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3139             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3140             case EF_SH3E: strcat (buf, ", sh3e"); break;
3141             case EF_SH4: strcat (buf, ", sh4"); break;
3142             case EF_SH5: strcat (buf, ", sh5"); break;
3143             case EF_SH2E: strcat (buf, ", sh2e"); break;
3144             case EF_SH4A: strcat (buf, ", sh4a"); break;
3145             case EF_SH2A: strcat (buf, ", sh2a"); break;
3146             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3147             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3148             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3149             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3150             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3151             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3152             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3153             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3154             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3155             default: strcat (buf, _(", unknown ISA")); break;
3156             }
3157
3158           if (e_flags & EF_SH_PIC)
3159             strcat (buf, ", pic");
3160
3161           if (e_flags & EF_SH_FDPIC)
3162             strcat (buf, ", fdpic");
3163           break;
3164
3165         case EM_OR1K:
3166           if (e_flags & EF_OR1K_NODELAY)
3167             strcat (buf, ", no delay");
3168           break;
3169
3170         case EM_SPARCV9:
3171           if (e_flags & EF_SPARC_32PLUS)
3172             strcat (buf, ", v8+");
3173
3174           if (e_flags & EF_SPARC_SUN_US1)
3175             strcat (buf, ", ultrasparcI");
3176
3177           if (e_flags & EF_SPARC_SUN_US3)
3178             strcat (buf, ", ultrasparcIII");
3179
3180           if (e_flags & EF_SPARC_HAL_R1)
3181             strcat (buf, ", halr1");
3182
3183           if (e_flags & EF_SPARC_LEDATA)
3184             strcat (buf, ", ledata");
3185
3186           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3187             strcat (buf, ", tso");
3188
3189           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3190             strcat (buf, ", pso");
3191
3192           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3193             strcat (buf, ", rmo");
3194           break;
3195
3196         case EM_PARISC:
3197           switch (e_flags & EF_PARISC_ARCH)
3198             {
3199             case EFA_PARISC_1_0:
3200               strcpy (buf, ", PA-RISC 1.0");
3201               break;
3202             case EFA_PARISC_1_1:
3203               strcpy (buf, ", PA-RISC 1.1");
3204               break;
3205             case EFA_PARISC_2_0:
3206               strcpy (buf, ", PA-RISC 2.0");
3207               break;
3208             default:
3209               break;
3210             }
3211           if (e_flags & EF_PARISC_TRAPNIL)
3212             strcat (buf, ", trapnil");
3213           if (e_flags & EF_PARISC_EXT)
3214             strcat (buf, ", ext");
3215           if (e_flags & EF_PARISC_LSB)
3216             strcat (buf, ", lsb");
3217           if (e_flags & EF_PARISC_WIDE)
3218             strcat (buf, ", wide");
3219           if (e_flags & EF_PARISC_NO_KABP)
3220             strcat (buf, ", no kabp");
3221           if (e_flags & EF_PARISC_LAZYSWAP)
3222             strcat (buf, ", lazyswap");
3223           break;
3224
3225         case EM_PJ:
3226         case EM_PJ_OLD:
3227           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3228             strcat (buf, ", new calling convention");
3229
3230           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3231             strcat (buf, ", gnu calling convention");
3232           break;
3233
3234         case EM_IA_64:
3235           if ((e_flags & EF_IA_64_ABI64))
3236             strcat (buf, ", 64-bit");
3237           else
3238             strcat (buf, ", 32-bit");
3239           if ((e_flags & EF_IA_64_REDUCEDFP))
3240             strcat (buf, ", reduced fp model");
3241           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3242             strcat (buf, ", no function descriptors, constant gp");
3243           else if ((e_flags & EF_IA_64_CONS_GP))
3244             strcat (buf, ", constant gp");
3245           if ((e_flags & EF_IA_64_ABSOLUTE))
3246             strcat (buf, ", absolute");
3247           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3248             {
3249               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3250                 strcat (buf, ", vms_linkages");
3251               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3252                 {
3253                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3254                   break;
3255                 case EF_IA_64_VMS_COMCOD_WARNING:
3256                   strcat (buf, ", warning");
3257                   break;
3258                 case EF_IA_64_VMS_COMCOD_ERROR:
3259                   strcat (buf, ", error");
3260                   break;
3261                 case EF_IA_64_VMS_COMCOD_ABORT:
3262                   strcat (buf, ", abort");
3263                   break;
3264                 default:
3265                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3266                         e_flags & EF_IA_64_VMS_COMCOD);
3267                   strcat (buf, ", <unknown>");
3268                 }
3269             }
3270           break;
3271
3272         case EM_VAX:
3273           if ((e_flags & EF_VAX_NONPIC))
3274             strcat (buf, ", non-PIC");
3275           if ((e_flags & EF_VAX_DFLOAT))
3276             strcat (buf, ", D-Float");
3277           if ((e_flags & EF_VAX_GFLOAT))
3278             strcat (buf, ", G-Float");
3279           break;
3280
3281         case EM_VISIUM:
3282           if (e_flags & EF_VISIUM_ARCH_MCM)
3283             strcat (buf, ", mcm");
3284           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3285             strcat (buf, ", mcm24");
3286           if (e_flags & EF_VISIUM_ARCH_GR6)
3287             strcat (buf, ", gr6");
3288           break;
3289
3290         case EM_RL78:
3291           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3292             {
3293             case E_FLAG_RL78_ANY_CPU: break;
3294             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3295             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3296             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3297             }
3298           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3299             strcat (buf, ", 64-bit doubles");
3300           break;
3301
3302         case EM_RX:
3303           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3304             strcat (buf, ", 64-bit doubles");
3305           if (e_flags & E_FLAG_RX_DSP)
3306             strcat (buf, ", dsp");
3307           if (e_flags & E_FLAG_RX_PID)
3308             strcat (buf, ", pid");
3309           if (e_flags & E_FLAG_RX_ABI)
3310             strcat (buf, ", RX ABI");
3311           if (e_flags & E_FLAG_RX_SINSNS_SET)
3312             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3313                     ? ", uses String instructions" : ", bans String instructions");
3314           break;
3315
3316         case EM_S390:
3317           if (e_flags & EF_S390_HIGH_GPRS)
3318             strcat (buf, ", highgprs");
3319           break;
3320
3321         case EM_TI_C6000:
3322           if ((e_flags & EF_C6000_REL))
3323             strcat (buf, ", relocatable module");
3324           break;
3325
3326         case EM_MSP430:
3327           strcat (buf, _(": architecture variant: "));
3328           switch (e_flags & EF_MSP430_MACH)
3329             {
3330             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3331             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3332             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3333             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3334             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3335             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3336             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3337             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3338             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3339             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3340             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3341             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3342             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3343             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3344             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3345             default:
3346               strcat (buf, _(": unknown")); break;
3347             }
3348
3349           if (e_flags & ~ EF_MSP430_MACH)
3350             strcat (buf, _(": unknown extra flag bits also present"));
3351         }
3352     }
3353
3354   return buf;
3355 }
3356
3357 static const char *
3358 get_osabi_name (unsigned int osabi)
3359 {
3360   static char buff[32];
3361
3362   switch (osabi)
3363     {
3364     case ELFOSABI_NONE:         return "UNIX - System V";
3365     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3366     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3367     case ELFOSABI_GNU:          return "UNIX - GNU";
3368     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3369     case ELFOSABI_AIX:          return "UNIX - AIX";
3370     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3371     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3372     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3373     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3374     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3375     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3376     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3377     case ELFOSABI_AROS:         return "AROS";
3378     case ELFOSABI_FENIXOS:      return "FenixOS";
3379     default:
3380       if (osabi >= 64)
3381         switch (elf_header.e_machine)
3382           {
3383           case EM_ARM:
3384             switch (osabi)
3385               {
3386               case ELFOSABI_ARM:        return "ARM";
3387               default:
3388                 break;
3389               }
3390             break;
3391
3392           case EM_MSP430:
3393           case EM_MSP430_OLD:
3394           case EM_VISIUM:
3395             switch (osabi)
3396               {
3397               case ELFOSABI_STANDALONE: return _("Standalone App");
3398               default:
3399                 break;
3400               }
3401             break;
3402
3403           case EM_TI_C6000:
3404             switch (osabi)
3405               {
3406               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3407               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3408               default:
3409                 break;
3410               }
3411             break;
3412
3413           default:
3414             break;
3415           }
3416       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3417       return buff;
3418     }
3419 }
3420
3421 static const char *
3422 get_aarch64_segment_type (unsigned long type)
3423 {
3424   switch (type)
3425     {
3426     case PT_AARCH64_ARCHEXT:
3427       return "AARCH64_ARCHEXT";
3428     default:
3429       break;
3430     }
3431
3432   return NULL;
3433 }
3434
3435 static const char *
3436 get_arm_segment_type (unsigned long type)
3437 {
3438   switch (type)
3439     {
3440     case PT_ARM_EXIDX:
3441       return "EXIDX";
3442     default:
3443       break;
3444     }
3445
3446   return NULL;
3447 }
3448
3449 static const char *
3450 get_mips_segment_type (unsigned long type)
3451 {
3452   switch (type)
3453     {
3454     case PT_MIPS_REGINFO:
3455       return "REGINFO";
3456     case PT_MIPS_RTPROC:
3457       return "RTPROC";
3458     case PT_MIPS_OPTIONS:
3459       return "OPTIONS";
3460     case PT_MIPS_ABIFLAGS:
3461       return "ABIFLAGS";
3462     default:
3463       break;
3464     }
3465
3466   return NULL;
3467 }
3468
3469 static const char *
3470 get_parisc_segment_type (unsigned long type)
3471 {
3472   switch (type)
3473     {
3474     case PT_HP_TLS:             return "HP_TLS";
3475     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3476     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3477     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3478     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3479     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3480     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3481     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3482     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3483     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3484     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3485     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3486     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3487     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3488     case PT_HP_STACK:           return "HP_STACK";
3489     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3490     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3491     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3492     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3493     default:
3494       break;
3495     }
3496
3497   return NULL;
3498 }
3499
3500 static const char *
3501 get_ia64_segment_type (unsigned long type)
3502 {
3503   switch (type)
3504     {
3505     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3506     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3507     case PT_HP_TLS:             return "HP_TLS";
3508     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3509     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3510     case PT_IA_64_HP_STACK:     return "HP_STACK";
3511     default:
3512       break;
3513     }
3514
3515   return NULL;
3516 }
3517
3518 static const char *
3519 get_tic6x_segment_type (unsigned long type)
3520 {
3521   switch (type)
3522     {
3523     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3524     default:
3525       break;
3526     }
3527
3528   return NULL;
3529 }
3530
3531 static const char *
3532 get_segment_type (unsigned long p_type)
3533 {
3534   static char buff[32];
3535
3536   switch (p_type)
3537     {
3538     case PT_NULL:       return "NULL";
3539     case PT_LOAD:       return "LOAD";
3540     case PT_DYNAMIC:    return "DYNAMIC";
3541     case PT_INTERP:     return "INTERP";
3542     case PT_NOTE:       return "NOTE";
3543     case PT_SHLIB:      return "SHLIB";
3544     case PT_PHDR:       return "PHDR";
3545     case PT_TLS:        return "TLS";
3546
3547     case PT_GNU_EH_FRAME:
3548                         return "GNU_EH_FRAME";
3549     case PT_GNU_STACK:  return "GNU_STACK";
3550     case PT_GNU_RELRO:  return "GNU_RELRO";
3551
3552     default:
3553       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3554         {
3555           const char * result;
3556
3557           switch (elf_header.e_machine)
3558             {
3559             case EM_AARCH64:
3560               result = get_aarch64_segment_type (p_type);
3561               break;
3562             case EM_ARM:
3563               result = get_arm_segment_type (p_type);
3564               break;
3565             case EM_MIPS:
3566             case EM_MIPS_RS3_LE:
3567               result = get_mips_segment_type (p_type);
3568               break;
3569             case EM_PARISC:
3570               result = get_parisc_segment_type (p_type);
3571               break;
3572             case EM_IA_64:
3573               result = get_ia64_segment_type (p_type);
3574               break;
3575             case EM_TI_C6000:
3576               result = get_tic6x_segment_type (p_type);
3577               break;
3578             default:
3579               result = NULL;
3580               break;
3581             }
3582
3583           if (result != NULL)
3584             return result;
3585
3586           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3587         }
3588       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3589         {
3590           const char * result;
3591
3592           switch (elf_header.e_machine)
3593             {
3594             case EM_PARISC:
3595               result = get_parisc_segment_type (p_type);
3596               break;
3597             case EM_IA_64:
3598               result = get_ia64_segment_type (p_type);
3599               break;
3600             default:
3601               result = NULL;
3602               break;
3603             }
3604
3605           if (result != NULL)
3606             return result;
3607
3608           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3609         }
3610       else
3611         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3612
3613       return buff;
3614     }
3615 }
3616
3617 static const char *
3618 get_mips_section_type_name (unsigned int sh_type)
3619 {
3620   switch (sh_type)
3621     {
3622     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3623     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3624     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3625     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3626     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3627     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3628     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3629     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3630     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3631     case SHT_MIPS_RELD:          return "MIPS_RELD";
3632     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3633     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3634     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3635     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3636     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3637     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3638     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3639     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3640     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3641     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3642     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3643     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3644     case SHT_MIPS_LINE:          return "MIPS_LINE";
3645     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3646     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3647     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3648     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3649     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3650     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3651     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3652     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3653     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3654     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3655     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3656     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3657     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3658     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3659     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3660     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3661     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3662     default:
3663       break;
3664     }
3665   return NULL;
3666 }
3667
3668 static const char *
3669 get_parisc_section_type_name (unsigned int sh_type)
3670 {
3671   switch (sh_type)
3672     {
3673     case SHT_PARISC_EXT:        return "PARISC_EXT";
3674     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3675     case SHT_PARISC_DOC:        return "PARISC_DOC";
3676     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3677     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3678     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3679     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3680     default:
3681       break;
3682     }
3683   return NULL;
3684 }
3685
3686 static const char *
3687 get_ia64_section_type_name (unsigned int sh_type)
3688 {
3689   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3690   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3691     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3692
3693   switch (sh_type)
3694     {
3695     case SHT_IA_64_EXT:                return "IA_64_EXT";
3696     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3697     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3698     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3699     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3700     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3701     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3702     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3703     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3704     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3705     default:
3706       break;
3707     }
3708   return NULL;
3709 }
3710
3711 static const char *
3712 get_x86_64_section_type_name (unsigned int sh_type)
3713 {
3714   switch (sh_type)
3715     {
3716     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3717     default:
3718       break;
3719     }
3720   return NULL;
3721 }
3722
3723 static const char *
3724 get_aarch64_section_type_name (unsigned int sh_type)
3725 {
3726   switch (sh_type)
3727     {
3728     case SHT_AARCH64_ATTRIBUTES:
3729       return "AARCH64_ATTRIBUTES";
3730     default:
3731       break;
3732     }
3733   return NULL;
3734 }
3735
3736 static const char *
3737 get_arm_section_type_name (unsigned int sh_type)
3738 {
3739   switch (sh_type)
3740     {
3741     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3742     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3743     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3744     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3745     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3746     default:
3747       break;
3748     }
3749   return NULL;
3750 }
3751
3752 static const char *
3753 get_tic6x_section_type_name (unsigned int sh_type)
3754 {
3755   switch (sh_type)
3756     {
3757     case SHT_C6000_UNWIND:
3758       return "C6000_UNWIND";
3759     case SHT_C6000_PREEMPTMAP:
3760       return "C6000_PREEMPTMAP";
3761     case SHT_C6000_ATTRIBUTES:
3762       return "C6000_ATTRIBUTES";
3763     case SHT_TI_ICODE:
3764       return "TI_ICODE";
3765     case SHT_TI_XREF:
3766       return "TI_XREF";
3767     case SHT_TI_HANDLER:
3768       return "TI_HANDLER";
3769     case SHT_TI_INITINFO:
3770       return "TI_INITINFO";
3771     case SHT_TI_PHATTRS:
3772       return "TI_PHATTRS";
3773     default:
3774       break;
3775     }
3776   return NULL;
3777 }
3778
3779 static const char *
3780 get_msp430x_section_type_name (unsigned int sh_type)
3781 {
3782   switch (sh_type)
3783     {
3784     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3785     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3786     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3787     default: return NULL;
3788     }
3789 }
3790
3791 static const char *
3792 get_v850_section_type_name (unsigned int sh_type)
3793 {
3794   switch (sh_type)
3795     {
3796     case SHT_V850_SCOMMON: return "V850 Small Common";
3797     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3798     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3799     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3800     case SHT_RENESAS_INFO: return "RENESAS INFO";
3801     default: return NULL;
3802     }
3803 }
3804
3805 static const char *
3806 get_section_type_name (unsigned int sh_type)
3807 {
3808   static char buff[32];
3809
3810   switch (sh_type)
3811     {
3812     case SHT_NULL:              return "NULL";
3813     case SHT_PROGBITS:          return "PROGBITS";
3814     case SHT_SYMTAB:            return "SYMTAB";
3815     case SHT_STRTAB:            return "STRTAB";
3816     case SHT_RELA:              return "RELA";
3817     case SHT_HASH:              return "HASH";
3818     case SHT_DYNAMIC:           return "DYNAMIC";
3819     case SHT_NOTE:              return "NOTE";
3820     case SHT_NOBITS:            return "NOBITS";
3821     case SHT_REL:               return "REL";
3822     case SHT_SHLIB:             return "SHLIB";
3823     case SHT_DYNSYM:            return "DYNSYM";
3824     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3825     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3826     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3827     case SHT_GNU_HASH:          return "GNU_HASH";
3828     case SHT_GROUP:             return "GROUP";
3829     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3830     case SHT_GNU_verdef:        return "VERDEF";
3831     case SHT_GNU_verneed:       return "VERNEED";
3832     case SHT_GNU_versym:        return "VERSYM";
3833     case 0x6ffffff0:            return "VERSYM";
3834     case 0x6ffffffc:            return "VERDEF";
3835     case 0x7ffffffd:            return "AUXILIARY";
3836     case 0x7fffffff:            return "FILTER";
3837     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3838
3839     default:
3840       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3841         {
3842           const char * result;
3843
3844           switch (elf_header.e_machine)
3845             {
3846             case EM_MIPS:
3847             case EM_MIPS_RS3_LE:
3848               result = get_mips_section_type_name (sh_type);
3849               break;
3850             case EM_PARISC:
3851               result = get_parisc_section_type_name (sh_type);
3852               break;
3853             case EM_IA_64:
3854               result = get_ia64_section_type_name (sh_type);
3855               break;
3856             case EM_X86_64:
3857             case EM_L1OM:
3858             case EM_K1OM:
3859               result = get_x86_64_section_type_name (sh_type);
3860               break;
3861             case EM_AARCH64:
3862               result = get_aarch64_section_type_name (sh_type);
3863               break;
3864             case EM_ARM:
3865               result = get_arm_section_type_name (sh_type);
3866               break;
3867             case EM_TI_C6000:
3868               result = get_tic6x_section_type_name (sh_type);
3869               break;
3870             case EM_MSP430:
3871               result = get_msp430x_section_type_name (sh_type);
3872               break;
3873             case EM_V800:
3874             case EM_V850:
3875             case EM_CYGNUS_V850:
3876               result = get_v850_section_type_name (sh_type);
3877               break;
3878             default:
3879               result = NULL;
3880               break;
3881             }
3882
3883           if (result != NULL)
3884             return result;
3885
3886           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3887         }
3888       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3889         {
3890           const char * result;
3891
3892           switch (elf_header.e_machine)
3893             {
3894             case EM_IA_64:
3895               result = get_ia64_section_type_name (sh_type);
3896               break;
3897             default:
3898               result = NULL;
3899               break;
3900             }
3901
3902           if (result != NULL)
3903             return result;
3904
3905           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3906         }
3907       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3908         {
3909           switch (elf_header.e_machine)
3910             {
3911             case EM_V800:
3912             case EM_V850:
3913             case EM_CYGNUS_V850:
3914               return get_v850_section_type_name (sh_type);
3915             default:
3916               break;
3917             }
3918
3919           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3920         }
3921       else
3922         /* This message is probably going to be displayed in a 15
3923            character wide field, so put the hex value first.  */
3924         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3925
3926       return buff;
3927     }
3928 }
3929
3930 #define OPTION_DEBUG_DUMP       512
3931 #define OPTION_DYN_SYMS         513
3932 #define OPTION_DWARF_DEPTH      514
3933 #define OPTION_DWARF_START      515
3934 #define OPTION_DWARF_CHECK      516
3935
3936 static struct option options[] =
3937 {
3938   {"all",              no_argument, 0, 'a'},
3939   {"file-header",      no_argument, 0, 'h'},
3940   {"program-headers",  no_argument, 0, 'l'},
3941   {"headers",          no_argument, 0, 'e'},
3942   {"histogram",        no_argument, 0, 'I'},
3943   {"segments",         no_argument, 0, 'l'},
3944   {"sections",         no_argument, 0, 'S'},
3945   {"section-headers",  no_argument, 0, 'S'},
3946   {"section-groups",   no_argument, 0, 'g'},
3947   {"section-details",  no_argument, 0, 't'},
3948   {"full-section-name",no_argument, 0, 'N'},
3949   {"symbols",          no_argument, 0, 's'},
3950   {"syms",             no_argument, 0, 's'},
3951   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3952   {"relocs",           no_argument, 0, 'r'},
3953   {"notes",            no_argument, 0, 'n'},
3954   {"dynamic",          no_argument, 0, 'd'},
3955   {"arch-specific",    no_argument, 0, 'A'},
3956   {"version-info",     no_argument, 0, 'V'},
3957   {"use-dynamic",      no_argument, 0, 'D'},
3958   {"unwind",           no_argument, 0, 'u'},
3959   {"archive-index",    no_argument, 0, 'c'},
3960   {"hex-dump",         required_argument, 0, 'x'},
3961   {"relocated-dump",   required_argument, 0, 'R'},
3962   {"string-dump",      required_argument, 0, 'p'},
3963 #ifdef SUPPORT_DISASSEMBLY
3964   {"instruction-dump", required_argument, 0, 'i'},
3965 #endif
3966   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3967
3968   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3969   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3970   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3971
3972   {"version",          no_argument, 0, 'v'},
3973   {"wide",             no_argument, 0, 'W'},
3974   {"help",             no_argument, 0, 'H'},
3975   {0,                  no_argument, 0, 0}
3976 };
3977
3978 static void
3979 usage (FILE * stream)
3980 {
3981   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3982   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3983   fprintf (stream, _(" Options are:\n\
3984   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3985   -h --file-header       Display the ELF file header\n\
3986   -l --program-headers   Display the program headers\n\
3987      --segments          An alias for --program-headers\n\
3988   -S --section-headers   Display the sections' header\n\
3989      --sections          An alias for --section-headers\n\
3990   -g --section-groups    Display the section groups\n\
3991   -t --section-details   Display the section details\n\
3992   -e --headers           Equivalent to: -h -l -S\n\
3993   -s --syms              Display the symbol table\n\
3994      --symbols           An alias for --syms\n\
3995   --dyn-syms             Display the dynamic symbol table\n\
3996   -n --notes             Display the core notes (if present)\n\
3997   -r --relocs            Display the relocations (if present)\n\
3998   -u --unwind            Display the unwind info (if present)\n\
3999   -d --dynamic           Display the dynamic section (if present)\n\
4000   -V --version-info      Display the version sections (if present)\n\
4001   -A --arch-specific     Display architecture specific information (if any)\n\
4002   -c --archive-index     Display the symbol/file index in an archive\n\
4003   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4004   -x --hex-dump=<number|name>\n\
4005                          Dump the contents of section <number|name> as bytes\n\
4006   -p --string-dump=<number|name>\n\
4007                          Dump the contents of section <number|name> as strings\n\
4008   -R --relocated-dump=<number|name>\n\
4009                          Dump the contents of section <number|name> as relocated bytes\n\
4010   -w[lLiaprmfFsoRt] or\n\
4011   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4012                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4013                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4014                =addr,=cu_index]\n\
4015                          Display the contents of DWARF2 debug sections\n"));
4016   fprintf (stream, _("\
4017   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4018   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4019                          or deeper\n"));
4020 #ifdef SUPPORT_DISASSEMBLY
4021   fprintf (stream, _("\
4022   -i --instruction-dump=<number|name>\n\
4023                          Disassemble the contents of section <number|name>\n"));
4024 #endif
4025   fprintf (stream, _("\
4026   -I --histogram         Display histogram of bucket list lengths\n\
4027   -W --wide              Allow output width to exceed 80 characters\n\
4028   @<file>                Read options from <file>\n\
4029   -H --help              Display this information\n\
4030   -v --version           Display the version number of readelf\n"));
4031
4032   if (REPORT_BUGS_TO[0] && stream == stdout)
4033     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4034
4035   exit (stream == stdout ? 0 : 1);
4036 }
4037
4038 /* Record the fact that the user wants the contents of section number
4039    SECTION to be displayed using the method(s) encoded as flags bits
4040    in TYPE.  Note, TYPE can be zero if we are creating the array for
4041    the first time.  */
4042
4043 static void
4044 request_dump_bynumber (unsigned int section, dump_type type)
4045 {
4046   if (section >= num_dump_sects)
4047     {
4048       dump_type * new_dump_sects;
4049
4050       new_dump_sects = (dump_type *) calloc (section + 1,
4051                                              sizeof (* dump_sects));
4052
4053       if (new_dump_sects == NULL)
4054         error (_("Out of memory allocating dump request table.\n"));
4055       else
4056         {
4057           /* Copy current flag settings.  */
4058           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4059
4060           free (dump_sects);
4061
4062           dump_sects = new_dump_sects;
4063           num_dump_sects = section + 1;
4064         }
4065     }
4066
4067   if (dump_sects)
4068     dump_sects[section] |= type;
4069
4070   return;
4071 }
4072
4073 /* Request a dump by section name.  */
4074
4075 static void
4076 request_dump_byname (const char * section, dump_type type)
4077 {
4078   struct dump_list_entry * new_request;
4079
4080   new_request = (struct dump_list_entry *)
4081       malloc (sizeof (struct dump_list_entry));
4082   if (!new_request)
4083     error (_("Out of memory allocating dump request table.\n"));
4084
4085   new_request->name = strdup (section);
4086   if (!new_request->name)
4087     error (_("Out of memory allocating dump request table.\n"));
4088
4089   new_request->type = type;
4090
4091   new_request->next = dump_sects_byname;
4092   dump_sects_byname = new_request;
4093 }
4094
4095 static inline void
4096 request_dump (dump_type type)
4097 {
4098   int section;
4099   char * cp;
4100
4101   do_dump++;
4102   section = strtoul (optarg, & cp, 0);
4103
4104   if (! *cp && section >= 0)
4105     request_dump_bynumber (section, type);
4106   else
4107     request_dump_byname (optarg, type);
4108 }
4109
4110
4111 static void
4112 parse_args (int argc, char ** argv)
4113 {
4114   int c;
4115
4116   if (argc < 2)
4117     usage (stderr);
4118
4119   while ((c = getopt_long
4120           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4121     {
4122       switch (c)
4123         {
4124         case 0:
4125           /* Long options.  */
4126           break;
4127         case 'H':
4128           usage (stdout);
4129           break;
4130
4131         case 'a':
4132           do_syms++;
4133           do_reloc++;
4134           do_unwind++;
4135           do_dynamic++;
4136           do_header++;
4137           do_sections++;
4138           do_section_groups++;
4139           do_segments++;
4140           do_version++;
4141           do_histogram++;
4142           do_arch++;
4143           do_notes++;
4144           break;
4145         case 'g':
4146           do_section_groups++;
4147           break;
4148         case 't':
4149         case 'N':
4150           do_sections++;
4151           do_section_details++;
4152           break;
4153         case 'e':
4154           do_header++;
4155           do_sections++;
4156           do_segments++;
4157           break;
4158         case 'A':
4159           do_arch++;
4160           break;
4161         case 'D':
4162           do_using_dynamic++;
4163           break;
4164         case 'r':
4165           do_reloc++;
4166           break;
4167         case 'u':
4168           do_unwind++;
4169           break;
4170         case 'h':
4171           do_header++;
4172           break;
4173         case 'l':
4174           do_segments++;
4175           break;
4176         case 's':
4177           do_syms++;
4178           break;
4179         case 'S':
4180           do_sections++;
4181           break;
4182         case 'd':
4183           do_dynamic++;
4184           break;
4185         case 'I':
4186           do_histogram++;
4187           break;
4188         case 'n':
4189           do_notes++;
4190           break;
4191         case 'c':
4192           do_archive_index++;
4193           break;
4194         case 'x':
4195           request_dump (HEX_DUMP);
4196           break;
4197         case 'p':
4198           request_dump (STRING_DUMP);
4199           break;
4200         case 'R':
4201           request_dump (RELOC_DUMP);
4202           break;
4203         case 'w':
4204           do_dump++;
4205           if (optarg == 0)
4206             {
4207               do_debugging = 1;
4208               dwarf_select_sections_all ();
4209             }
4210           else
4211             {
4212               do_debugging = 0;
4213               dwarf_select_sections_by_letters (optarg);
4214             }
4215           break;
4216         case OPTION_DEBUG_DUMP:
4217           do_dump++;
4218           if (optarg == 0)
4219             do_debugging = 1;
4220           else
4221             {
4222               do_debugging = 0;
4223               dwarf_select_sections_by_names (optarg);
4224             }
4225           break;
4226         case OPTION_DWARF_DEPTH:
4227           {
4228             char *cp;
4229
4230             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4231           }
4232           break;
4233         case OPTION_DWARF_START:
4234           {
4235             char *cp;
4236
4237             dwarf_start_die = strtoul (optarg, & cp, 0);
4238           }
4239           break;
4240         case OPTION_DWARF_CHECK:
4241           dwarf_check = 1;
4242           break;
4243         case OPTION_DYN_SYMS:
4244           do_dyn_syms++;
4245           break;
4246 #ifdef SUPPORT_DISASSEMBLY
4247         case 'i':
4248           request_dump (DISASS_DUMP);
4249           break;
4250 #endif
4251         case 'v':
4252           print_version (program_name);
4253           break;
4254         case 'V':
4255           do_version++;
4256           break;
4257         case 'W':
4258           do_wide++;
4259           break;
4260         default:
4261           /* xgettext:c-format */
4262           error (_("Invalid option '-%c'\n"), c);
4263           /* Drop through.  */
4264         case '?':
4265           usage (stderr);
4266         }
4267     }
4268
4269   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4270       && !do_segments && !do_header && !do_dump && !do_version
4271       && !do_histogram && !do_debugging && !do_arch && !do_notes
4272       && !do_section_groups && !do_archive_index
4273       && !do_dyn_syms)
4274     usage (stderr);
4275 }
4276
4277 static const char *
4278 get_elf_class (unsigned int elf_class)
4279 {
4280   static char buff[32];
4281
4282   switch (elf_class)
4283     {
4284     case ELFCLASSNONE: return _("none");
4285     case ELFCLASS32:   return "ELF32";
4286     case ELFCLASS64:   return "ELF64";
4287     default:
4288       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4289       return buff;
4290     }
4291 }
4292
4293 static const char *
4294 get_data_encoding (unsigned int encoding)
4295 {
4296   static char buff[32];
4297
4298   switch (encoding)
4299     {
4300     case ELFDATANONE: return _("none");
4301     case ELFDATA2LSB: return _("2's complement, little endian");
4302     case ELFDATA2MSB: return _("2's complement, big endian");
4303     default:
4304       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4305       return buff;
4306     }
4307 }
4308
4309 /* Decode the data held in 'elf_header'.  */
4310
4311 static int
4312 process_file_header (void)
4313 {
4314   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4315       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4316       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4317       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4318     {
4319       error
4320         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4321       return 0;
4322     }
4323
4324   init_dwarf_regnames (elf_header.e_machine);
4325
4326   if (do_header)
4327     {
4328       int i;
4329
4330       printf (_("ELF Header:\n"));
4331       printf (_("  Magic:   "));
4332       for (i = 0; i < EI_NIDENT; i++)
4333         printf ("%2.2x ", elf_header.e_ident[i]);
4334       printf ("\n");
4335       printf (_("  Class:                             %s\n"),
4336               get_elf_class (elf_header.e_ident[EI_CLASS]));
4337       printf (_("  Data:                              %s\n"),
4338               get_data_encoding (elf_header.e_ident[EI_DATA]));
4339       printf (_("  Version:                           %d %s\n"),
4340               elf_header.e_ident[EI_VERSION],
4341               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4342                ? "(current)"
4343                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4344                   ? _("<unknown: %lx>")
4345                   : "")));
4346       printf (_("  OS/ABI:                            %s\n"),
4347               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4348       printf (_("  ABI Version:                       %d\n"),
4349               elf_header.e_ident[EI_ABIVERSION]);
4350       printf (_("  Type:                              %s\n"),
4351               get_file_type (elf_header.e_type));
4352       printf (_("  Machine:                           %s\n"),
4353               get_machine_name (elf_header.e_machine));
4354       printf (_("  Version:                           0x%lx\n"),
4355               (unsigned long) elf_header.e_version);
4356
4357       printf (_("  Entry point address:               "));
4358       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4359       printf (_("\n  Start of program headers:          "));
4360       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4361       printf (_(" (bytes into file)\n  Start of section headers:          "));
4362       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4363       printf (_(" (bytes into file)\n"));
4364
4365       printf (_("  Flags:                             0x%lx%s\n"),
4366               (unsigned long) elf_header.e_flags,
4367               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4368       printf (_("  Size of this header:               %ld (bytes)\n"),
4369               (long) elf_header.e_ehsize);
4370       printf (_("  Size of program headers:           %ld (bytes)\n"),
4371               (long) elf_header.e_phentsize);
4372       printf (_("  Number of program headers:         %ld"),
4373               (long) elf_header.e_phnum);
4374       if (section_headers != NULL
4375           && elf_header.e_phnum == PN_XNUM
4376           && section_headers[0].sh_info != 0)
4377         printf (" (%ld)", (long) section_headers[0].sh_info);
4378       putc ('\n', stdout);
4379       printf (_("  Size of section headers:           %ld (bytes)\n"),
4380               (long) elf_header.e_shentsize);
4381       printf (_("  Number of section headers:         %ld"),
4382               (long) elf_header.e_shnum);
4383       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4384         printf (" (%ld)", (long) section_headers[0].sh_size);
4385       putc ('\n', stdout);
4386       printf (_("  Section header string table index: %ld"),
4387               (long) elf_header.e_shstrndx);
4388       if (section_headers != NULL
4389           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4390         printf (" (%u)", section_headers[0].sh_link);
4391       else if (elf_header.e_shstrndx != SHN_UNDEF
4392                && elf_header.e_shstrndx >= elf_header.e_shnum)
4393         printf (_(" <corrupt: out of range>"));
4394       putc ('\n', stdout);
4395     }
4396
4397   if (section_headers != NULL)
4398     {
4399       if (elf_header.e_phnum == PN_XNUM
4400           && section_headers[0].sh_info != 0)
4401         elf_header.e_phnum = section_headers[0].sh_info;
4402       if (elf_header.e_shnum == SHN_UNDEF)
4403         elf_header.e_shnum = section_headers[0].sh_size;
4404       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4405         elf_header.e_shstrndx = section_headers[0].sh_link;
4406       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4407         elf_header.e_shstrndx = SHN_UNDEF;
4408       free (section_headers);
4409       section_headers = NULL;
4410     }
4411
4412   return 1;
4413 }
4414
4415 static bfd_boolean
4416 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4417 {
4418   Elf32_External_Phdr * phdrs;
4419   Elf32_External_Phdr * external;
4420   Elf_Internal_Phdr *   internal;
4421   unsigned int i;
4422   unsigned int size = elf_header.e_phentsize;
4423   unsigned int num  = elf_header.e_phnum;
4424
4425   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4426   if (size == 0 || num == 0)
4427     return FALSE;
4428   if (size < sizeof * phdrs)
4429     {
4430       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4431       return FALSE;
4432     }
4433   if (size > sizeof * phdrs)
4434     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4435
4436   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4437                                             size, num, _("program headers"));
4438   if (phdrs == NULL)
4439     return FALSE;
4440
4441   for (i = 0, internal = pheaders, external = phdrs;
4442        i < elf_header.e_phnum;
4443        i++, internal++, external++)
4444     {
4445       internal->p_type   = BYTE_GET (external->p_type);
4446       internal->p_offset = BYTE_GET (external->p_offset);
4447       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4448       internal->p_paddr  = BYTE_GET (external->p_paddr);
4449       internal->p_filesz = BYTE_GET (external->p_filesz);
4450       internal->p_memsz  = BYTE_GET (external->p_memsz);
4451       internal->p_flags  = BYTE_GET (external->p_flags);
4452       internal->p_align  = BYTE_GET (external->p_align);
4453     }
4454
4455   free (phdrs);
4456   return TRUE;
4457 }
4458
4459 static bfd_boolean
4460 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4461 {
4462   Elf64_External_Phdr * phdrs;
4463   Elf64_External_Phdr * external;
4464   Elf_Internal_Phdr *   internal;
4465   unsigned int i;
4466   unsigned int size = elf_header.e_phentsize;
4467   unsigned int num  = elf_header.e_phnum;
4468
4469   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4470   if (size == 0 || num == 0)
4471     return FALSE;
4472   if (size < sizeof * phdrs)
4473     {
4474       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4475       return FALSE;
4476     }
4477   if (size > sizeof * phdrs)
4478     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4479
4480   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4481                                             size, num, _("program headers"));
4482   if (!phdrs)
4483     return FALSE;
4484
4485   for (i = 0, internal = pheaders, external = phdrs;
4486        i < elf_header.e_phnum;
4487        i++, internal++, external++)
4488     {
4489       internal->p_type   = BYTE_GET (external->p_type);
4490       internal->p_flags  = BYTE_GET (external->p_flags);
4491       internal->p_offset = BYTE_GET (external->p_offset);
4492       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4493       internal->p_paddr  = BYTE_GET (external->p_paddr);
4494       internal->p_filesz = BYTE_GET (external->p_filesz);
4495       internal->p_memsz  = BYTE_GET (external->p_memsz);
4496       internal->p_align  = BYTE_GET (external->p_align);
4497     }
4498
4499   free (phdrs);
4500   return TRUE;
4501 }
4502
4503 /* Returns 1 if the program headers were read into `program_headers'.  */
4504
4505 static int
4506 get_program_headers (FILE * file)
4507 {
4508   Elf_Internal_Phdr * phdrs;
4509
4510   /* Check cache of prior read.  */
4511   if (program_headers != NULL)
4512     return 1;
4513
4514   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4515                                          sizeof (Elf_Internal_Phdr));
4516
4517   if (phdrs == NULL)
4518     {
4519       error (_("Out of memory reading %u program headers\n"),
4520              elf_header.e_phnum);
4521       return 0;
4522     }
4523
4524   if (is_32bit_elf
4525       ? get_32bit_program_headers (file, phdrs)
4526       : get_64bit_program_headers (file, phdrs))
4527     {
4528       program_headers = phdrs;
4529       return 1;
4530     }
4531
4532   free (phdrs);
4533   return 0;
4534 }
4535
4536 /* Returns 1 if the program headers were loaded.  */
4537
4538 static int
4539 process_program_headers (FILE * file)
4540 {
4541   Elf_Internal_Phdr * segment;
4542   unsigned int i;
4543
4544   if (elf_header.e_phnum == 0)
4545     {
4546       /* PR binutils/12467.  */
4547       if (elf_header.e_phoff != 0)
4548         warn (_("possibly corrupt ELF header - it has a non-zero program"
4549                 " header offset, but no program headers\n"));
4550       else if (do_segments)
4551         printf (_("\nThere are no program headers in this file.\n"));
4552       return 0;
4553     }
4554
4555   if (do_segments && !do_header)
4556     {
4557       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4558       printf (_("Entry point "));
4559       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4560       printf (_("\nThere are %d program headers, starting at offset "),
4561               elf_header.e_phnum);
4562       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4563       printf ("\n");
4564     }
4565
4566   if (! get_program_headers (file))
4567       return 0;
4568
4569   if (do_segments)
4570     {
4571       if (elf_header.e_phnum > 1)
4572         printf (_("\nProgram Headers:\n"));
4573       else
4574         printf (_("\nProgram Headers:\n"));
4575
4576       if (is_32bit_elf)
4577         printf
4578           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4579       else if (do_wide)
4580         printf
4581           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4582       else
4583         {
4584           printf
4585             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4586           printf
4587             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4588         }
4589     }
4590
4591   dynamic_addr = 0;
4592   dynamic_size = 0;
4593
4594   for (i = 0, segment = program_headers;
4595        i < elf_header.e_phnum;
4596        i++, segment++)
4597     {
4598       if (do_segments)
4599         {
4600           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4601
4602           if (is_32bit_elf)
4603             {
4604               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4605               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4606               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4607               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4608               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4609               printf ("%c%c%c ",
4610                       (segment->p_flags & PF_R ? 'R' : ' '),
4611                       (segment->p_flags & PF_W ? 'W' : ' '),
4612                       (segment->p_flags & PF_X ? 'E' : ' '));
4613               printf ("%#lx", (unsigned long) segment->p_align);
4614             }
4615           else if (do_wide)
4616             {
4617               if ((unsigned long) segment->p_offset == segment->p_offset)
4618                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4619               else
4620                 {
4621                   print_vma (segment->p_offset, FULL_HEX);
4622                   putchar (' ');
4623                 }
4624
4625               print_vma (segment->p_vaddr, FULL_HEX);
4626               putchar (' ');
4627               print_vma (segment->p_paddr, FULL_HEX);
4628               putchar (' ');
4629
4630               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4631                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4632               else
4633                 {
4634                   print_vma (segment->p_filesz, FULL_HEX);
4635                   putchar (' ');
4636                 }
4637
4638               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4639                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4640               else
4641                 {
4642                   print_vma (segment->p_memsz, FULL_HEX);
4643                 }
4644
4645               printf (" %c%c%c ",
4646                       (segment->p_flags & PF_R ? 'R' : ' '),
4647                       (segment->p_flags & PF_W ? 'W' : ' '),
4648                       (segment->p_flags & PF_X ? 'E' : ' '));
4649
4650               if ((unsigned long) segment->p_align == segment->p_align)
4651                 printf ("%#lx", (unsigned long) segment->p_align);
4652               else
4653                 {
4654                   print_vma (segment->p_align, PREFIX_HEX);
4655                 }
4656             }
4657           else
4658             {
4659               print_vma (segment->p_offset, FULL_HEX);
4660               putchar (' ');
4661               print_vma (segment->p_vaddr, FULL_HEX);
4662               putchar (' ');
4663               print_vma (segment->p_paddr, FULL_HEX);
4664               printf ("\n                 ");
4665               print_vma (segment->p_filesz, FULL_HEX);
4666               putchar (' ');
4667               print_vma (segment->p_memsz, FULL_HEX);
4668               printf ("  %c%c%c    ",
4669                       (segment->p_flags & PF_R ? 'R' : ' '),
4670                       (segment->p_flags & PF_W ? 'W' : ' '),
4671                       (segment->p_flags & PF_X ? 'E' : ' '));
4672               print_vma (segment->p_align, HEX);
4673             }
4674         }
4675
4676       if (do_segments)
4677         putc ('\n', stdout);
4678
4679       switch (segment->p_type)
4680         {
4681         case PT_DYNAMIC:
4682           if (dynamic_addr)
4683             error (_("more than one dynamic segment\n"));
4684
4685           /* By default, assume that the .dynamic section is the first
4686              section in the DYNAMIC segment.  */
4687           dynamic_addr = segment->p_offset;
4688           dynamic_size = segment->p_filesz;
4689           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4690           if (dynamic_addr + dynamic_size >= current_file_size)
4691             {
4692               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4693               dynamic_addr = dynamic_size = 0;
4694             }
4695
4696           /* Try to locate the .dynamic section. If there is
4697              a section header table, we can easily locate it.  */
4698           if (section_headers != NULL)
4699             {
4700               Elf_Internal_Shdr * sec;
4701
4702               sec = find_section (".dynamic");
4703               if (sec == NULL || sec->sh_size == 0)
4704                 {
4705                   /* A corresponding .dynamic section is expected, but on
4706                      IA-64/OpenVMS it is OK for it to be missing.  */
4707                   if (!is_ia64_vms ())
4708                     error (_("no .dynamic section in the dynamic segment\n"));
4709                   break;
4710                 }
4711
4712               if (sec->sh_type == SHT_NOBITS)
4713                 {
4714                   dynamic_size = 0;
4715                   break;
4716                 }
4717
4718               dynamic_addr = sec->sh_offset;
4719               dynamic_size = sec->sh_size;
4720
4721               if (dynamic_addr < segment->p_offset
4722                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4723                 warn (_("the .dynamic section is not contained"
4724                         " within the dynamic segment\n"));
4725               else if (dynamic_addr > segment->p_offset)
4726                 warn (_("the .dynamic section is not the first section"
4727                         " in the dynamic segment.\n"));
4728             }
4729           break;
4730
4731         case PT_INTERP:
4732           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4733                      SEEK_SET))
4734             error (_("Unable to find program interpreter name\n"));
4735           else
4736             {
4737               char fmt [32];
4738               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4739
4740               if (ret >= (int) sizeof (fmt) || ret < 0)
4741                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4742
4743               program_interpreter[0] = 0;
4744               if (fscanf (file, fmt, program_interpreter) <= 0)
4745                 error (_("Unable to read program interpreter name\n"));
4746
4747               if (do_segments)
4748                 printf (_("      [Requesting program interpreter: %s]\n"),
4749                     program_interpreter);
4750             }
4751           break;
4752         }
4753     }
4754
4755   if (do_segments && section_headers != NULL && string_table != NULL)
4756     {
4757       printf (_("\n Section to Segment mapping:\n"));
4758       printf (_("  Segment Sections...\n"));
4759
4760       for (i = 0; i < elf_header.e_phnum; i++)
4761         {
4762           unsigned int j;
4763           Elf_Internal_Shdr * section;
4764
4765           segment = program_headers + i;
4766           section = section_headers + 1;
4767
4768           printf ("   %2.2d     ", i);
4769
4770           for (j = 1; j < elf_header.e_shnum; j++, section++)
4771             {
4772               if (!ELF_TBSS_SPECIAL (section, segment)
4773                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4774                 printf ("%s ", printable_section_name (section));
4775             }
4776
4777           putc ('\n',stdout);
4778         }
4779     }
4780
4781   return 1;
4782 }
4783
4784
4785 /* Find the file offset corresponding to VMA by using the program headers.  */
4786
4787 static long
4788 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4789 {
4790   Elf_Internal_Phdr * seg;
4791
4792   if (! get_program_headers (file))
4793     {
4794       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4795       return (long) vma;
4796     }
4797
4798   for (seg = program_headers;
4799        seg < program_headers + elf_header.e_phnum;
4800        ++seg)
4801     {
4802       if (seg->p_type != PT_LOAD)
4803         continue;
4804
4805       if (vma >= (seg->p_vaddr & -seg->p_align)
4806           && vma + size <= seg->p_vaddr + seg->p_filesz)
4807         return vma - seg->p_vaddr + seg->p_offset;
4808     }
4809
4810   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4811         (unsigned long) vma);
4812   return (long) vma;
4813 }
4814
4815
4816 /* Allocate memory and load the sections headers into the global pointer
4817    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4818    generate any error messages if the load fails.  */
4819
4820 static bfd_boolean
4821 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4822 {
4823   Elf32_External_Shdr * shdrs;
4824   Elf_Internal_Shdr *   internal;
4825   unsigned int i;
4826   unsigned int size = elf_header.e_shentsize;
4827   unsigned int num = probe ? 1 : elf_header.e_shnum;
4828
4829   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4830   if (size == 0 || num == 0)
4831     return FALSE;
4832   if (size < sizeof * shdrs)
4833     {
4834       if (! probe)
4835         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4836       return FALSE;
4837     }
4838   if (!probe && size > sizeof * shdrs)
4839     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4840
4841   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4842                                             size, num,
4843                                             probe ? NULL : _("section headers"));
4844   if (shdrs == NULL)
4845     return FALSE;
4846
4847   if (section_headers != NULL)
4848     free (section_headers);
4849   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4850                                                    sizeof (Elf_Internal_Shdr));
4851   if (section_headers == NULL)
4852     {
4853       if (!probe)
4854         error (_("Out of memory reading %u section headers\n"), num);
4855       return FALSE;
4856     }
4857
4858   for (i = 0, internal = section_headers;
4859        i < num;
4860        i++, internal++)
4861     {
4862       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4863       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4864       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4865       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4866       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4867       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4868       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4869       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4870       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4871       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4872     }
4873
4874   free (shdrs);
4875   return TRUE;
4876 }
4877
4878 static bfd_boolean
4879 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4880 {
4881   Elf64_External_Shdr * shdrs;
4882   Elf_Internal_Shdr *   internal;
4883   unsigned int i;
4884   unsigned int size = elf_header.e_shentsize;
4885   unsigned int num = probe ? 1 : elf_header.e_shnum;
4886
4887   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4888   if (size == 0 || num == 0)
4889     return FALSE;
4890   if (size < sizeof * shdrs)
4891     {
4892       if (! probe)
4893         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4894       return FALSE;
4895     }
4896   if (! probe && size > sizeof * shdrs)
4897     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4898
4899   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4900                                             size, num,
4901                                             probe ? NULL : _("section headers"));
4902   if (shdrs == NULL)
4903     return FALSE;
4904
4905   if (section_headers != NULL)
4906     free (section_headers);
4907   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4908                                                    sizeof (Elf_Internal_Shdr));
4909   if (section_headers == NULL)
4910     {
4911       if (! probe)
4912         error (_("Out of memory reading %u section headers\n"), num);
4913       return FALSE;
4914     }
4915
4916   for (i = 0, internal = section_headers;
4917        i < num;
4918        i++, internal++)
4919     {
4920       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4921       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4922       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4923       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4924       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4925       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4926       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4927       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4928       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4929       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4930     }
4931
4932   free (shdrs);
4933   return TRUE;
4934 }
4935
4936 static Elf_Internal_Sym *
4937 get_32bit_elf_symbols (FILE * file,
4938                        Elf_Internal_Shdr * section,
4939                        unsigned long * num_syms_return)
4940 {
4941   unsigned long number = 0;
4942   Elf32_External_Sym * esyms = NULL;
4943   Elf_External_Sym_Shndx * shndx = NULL;
4944   Elf_Internal_Sym * isyms = NULL;
4945   Elf_Internal_Sym * psym;
4946   unsigned int j;
4947
4948   if (section->sh_size == 0)
4949     {
4950       if (num_syms_return != NULL)
4951         * num_syms_return = 0;
4952       return NULL;
4953     }
4954
4955   /* Run some sanity checks first.  */
4956   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4957     {
4958       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4959              printable_section_name (section), (unsigned long) section->sh_entsize);
4960       goto exit_point;
4961     }
4962
4963   if (section->sh_size > current_file_size)
4964     {
4965       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4966              printable_section_name (section), (unsigned long) section->sh_size);
4967       goto exit_point;
4968     }
4969
4970   number = section->sh_size / section->sh_entsize;
4971
4972   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4973     {
4974       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4975              (unsigned long) section->sh_size,
4976              printable_section_name (section),
4977              (unsigned long) section->sh_entsize);
4978       goto exit_point;
4979     }
4980
4981   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4982                                            section->sh_size, _("symbols"));
4983   if (esyms == NULL)
4984     goto exit_point;
4985
4986   shndx = NULL;
4987   if (symtab_shndx_hdr != NULL
4988       && (symtab_shndx_hdr->sh_link
4989           == (unsigned long) (section - section_headers)))
4990     {
4991       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4992                                                    symtab_shndx_hdr->sh_offset,
4993                                                    1, symtab_shndx_hdr->sh_size,
4994                                                    _("symbol table section indicies"));
4995       if (shndx == NULL)
4996         goto exit_point;
4997       /* PR17531: file: heap-buffer-overflow */
4998       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4999         {
5000           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5001                  printable_section_name (symtab_shndx_hdr),
5002                  (unsigned long) symtab_shndx_hdr->sh_size,
5003                  (unsigned long) section->sh_size);
5004           goto exit_point;
5005         }
5006     }
5007
5008   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5009
5010   if (isyms == NULL)
5011     {
5012       error (_("Out of memory reading %lu symbols\n"),
5013              (unsigned long) number);
5014       goto exit_point;
5015     }
5016
5017   for (j = 0, psym = isyms; j < number; j++, psym++)
5018     {
5019       psym->st_name  = BYTE_GET (esyms[j].st_name);
5020       psym->st_value = BYTE_GET (esyms[j].st_value);
5021       psym->st_size  = BYTE_GET (esyms[j].st_size);
5022       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5023       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5024         psym->st_shndx
5025           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5026       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5027         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5028       psym->st_info  = BYTE_GET (esyms[j].st_info);
5029       psym->st_other = BYTE_GET (esyms[j].st_other);
5030     }
5031
5032  exit_point:
5033   if (shndx != NULL)
5034     free (shndx);
5035   if (esyms != NULL)
5036     free (esyms);
5037
5038   if (num_syms_return != NULL)
5039     * num_syms_return = isyms == NULL ? 0 : number;
5040
5041   return isyms;
5042 }
5043
5044 static Elf_Internal_Sym *
5045 get_64bit_elf_symbols (FILE * file,
5046                        Elf_Internal_Shdr * section,
5047                        unsigned long * num_syms_return)
5048 {
5049   unsigned long number = 0;
5050   Elf64_External_Sym * esyms = NULL;
5051   Elf_External_Sym_Shndx * shndx = NULL;
5052   Elf_Internal_Sym * isyms = NULL;
5053   Elf_Internal_Sym * psym;
5054   unsigned int j;
5055
5056   if (section->sh_size == 0)
5057     {
5058       if (num_syms_return != NULL)
5059         * num_syms_return = 0;
5060       return NULL;
5061     }
5062
5063   /* Run some sanity checks first.  */
5064   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5065     {
5066       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5067              printable_section_name (section),
5068              (unsigned long) section->sh_entsize);
5069       goto exit_point;
5070     }
5071
5072   if (section->sh_size > current_file_size)
5073     {
5074       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5075              printable_section_name (section),
5076              (unsigned long) section->sh_size);
5077       goto exit_point;
5078     }
5079
5080   number = section->sh_size / section->sh_entsize;
5081
5082   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5083     {
5084       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5085              (unsigned long) section->sh_size,
5086              printable_section_name (section),
5087              (unsigned long) section->sh_entsize);
5088       goto exit_point;
5089     }
5090
5091   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5092                                            section->sh_size, _("symbols"));
5093   if (!esyms)
5094     goto exit_point;
5095
5096   if (symtab_shndx_hdr != NULL
5097       && (symtab_shndx_hdr->sh_link
5098           == (unsigned long) (section - section_headers)))
5099     {
5100       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5101                                                    symtab_shndx_hdr->sh_offset,
5102                                                    1, symtab_shndx_hdr->sh_size,
5103                                                    _("symbol table section indicies"));
5104       if (shndx == NULL)
5105         goto exit_point;
5106       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5107         {
5108           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5109                  printable_section_name (symtab_shndx_hdr),
5110                  (unsigned long) symtab_shndx_hdr->sh_size,
5111                  (unsigned long) section->sh_size);
5112           goto exit_point;
5113         }
5114     }
5115
5116   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5117
5118   if (isyms == NULL)
5119     {
5120       error (_("Out of memory reading %lu symbols\n"),
5121              (unsigned long) number);
5122       goto exit_point;
5123     }
5124
5125   for (j = 0, psym = isyms; j < number; j++, psym++)
5126     {
5127       psym->st_name  = BYTE_GET (esyms[j].st_name);
5128       psym->st_info  = BYTE_GET (esyms[j].st_info);
5129       psym->st_other = BYTE_GET (esyms[j].st_other);
5130       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5131
5132       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5133         psym->st_shndx
5134           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5135       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5136         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5137
5138       psym->st_value = BYTE_GET (esyms[j].st_value);
5139       psym->st_size  = BYTE_GET (esyms[j].st_size);
5140     }
5141
5142  exit_point:
5143   if (shndx != NULL)
5144     free (shndx);
5145   if (esyms != NULL)
5146     free (esyms);
5147
5148   if (num_syms_return != NULL)
5149     * num_syms_return = isyms == NULL ? 0 : number;
5150
5151   return isyms;
5152 }
5153
5154 static const char *
5155 get_elf_section_flags (bfd_vma sh_flags)
5156 {
5157   static char buff[1024];
5158   char * p = buff;
5159   int field_size = is_32bit_elf ? 8 : 16;
5160   int sindex;
5161   int size = sizeof (buff) - (field_size + 4 + 1);
5162   bfd_vma os_flags = 0;
5163   bfd_vma proc_flags = 0;
5164   bfd_vma unknown_flags = 0;
5165   static const struct
5166     {
5167       const char * str;
5168       int len;
5169     }
5170   flags [] =
5171     {
5172       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5173       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5174       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5175       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5176       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5177       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5178       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5179       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5180       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5181       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5182       /* IA-64 specific.  */
5183       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5184       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5185       /* IA-64 OpenVMS specific.  */
5186       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5187       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5188       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5189       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5190       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5191       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5192       /* Generic.  */
5193       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5194       /* SPARC specific.  */
5195       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5196       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5197     };
5198
5199   if (do_section_details)
5200     {
5201       sprintf (buff, "[%*.*lx]: ",
5202                field_size, field_size, (unsigned long) sh_flags);
5203       p += field_size + 4;
5204     }
5205
5206   while (sh_flags)
5207     {
5208       bfd_vma flag;
5209
5210       flag = sh_flags & - sh_flags;
5211       sh_flags &= ~ flag;
5212
5213       if (do_section_details)
5214         {
5215           switch (flag)
5216             {
5217             case SHF_WRITE:             sindex = 0; break;
5218             case SHF_ALLOC:             sindex = 1; break;
5219             case SHF_EXECINSTR:         sindex = 2; break;
5220             case SHF_MERGE:             sindex = 3; break;
5221             case SHF_STRINGS:           sindex = 4; break;
5222             case SHF_INFO_LINK:         sindex = 5; break;
5223             case SHF_LINK_ORDER:        sindex = 6; break;
5224             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5225             case SHF_GROUP:             sindex = 8; break;
5226             case SHF_TLS:               sindex = 9; break;
5227             case SHF_EXCLUDE:           sindex = 18; break;
5228             case SHF_COMPRESSED:        sindex = 20; break;
5229
5230             default:
5231               sindex = -1;
5232               switch (elf_header.e_machine)
5233                 {
5234                 case EM_IA_64:
5235                   if (flag == SHF_IA_64_SHORT)
5236                     sindex = 10;
5237                   else if (flag == SHF_IA_64_NORECOV)
5238                     sindex = 11;
5239 #ifdef BFD64
5240                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5241                     switch (flag)
5242                       {
5243                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5244                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5245                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5246                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5247                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5248                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5249                       default:                        break;
5250                       }
5251 #endif
5252                   break;
5253
5254                 case EM_386:
5255                 case EM_486:
5256                 case EM_X86_64:
5257                 case EM_L1OM:
5258                 case EM_K1OM:
5259                 case EM_OLD_SPARCV9:
5260                 case EM_SPARC32PLUS:
5261                 case EM_SPARCV9:
5262                 case EM_SPARC:
5263                   if (flag == SHF_ORDERED)
5264                     sindex = 19;
5265                   break;
5266                 default:
5267                   break;
5268                 }
5269             }
5270
5271           if (sindex != -1)
5272             {
5273               if (p != buff + field_size + 4)
5274                 {
5275                   if (size < (10 + 2))
5276                     {
5277                       warn (_("Internal error: not enough buffer room for section flag info"));
5278                       return _("<unknown>");
5279                     }
5280                   size -= 2;
5281                   *p++ = ',';
5282                   *p++ = ' ';
5283                 }
5284
5285               size -= flags [sindex].len;
5286               p = stpcpy (p, flags [sindex].str);
5287             }
5288           else if (flag & SHF_MASKOS)
5289             os_flags |= flag;
5290           else if (flag & SHF_MASKPROC)
5291             proc_flags |= flag;
5292           else
5293             unknown_flags |= flag;
5294         }
5295       else
5296         {
5297           switch (flag)
5298             {
5299             case SHF_WRITE:             *p = 'W'; break;
5300             case SHF_ALLOC:             *p = 'A'; break;
5301             case SHF_EXECINSTR:         *p = 'X'; break;
5302             case SHF_MERGE:             *p = 'M'; break;
5303             case SHF_STRINGS:           *p = 'S'; break;
5304             case SHF_INFO_LINK:         *p = 'I'; break;
5305             case SHF_LINK_ORDER:        *p = 'L'; break;
5306             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5307             case SHF_GROUP:             *p = 'G'; break;
5308             case SHF_TLS:               *p = 'T'; break;
5309             case SHF_EXCLUDE:           *p = 'E'; break;
5310             case SHF_COMPRESSED:        *p = 'C'; break;
5311
5312             default:
5313               if ((elf_header.e_machine == EM_X86_64
5314                    || elf_header.e_machine == EM_L1OM
5315                    || elf_header.e_machine == EM_K1OM)
5316                   && flag == SHF_X86_64_LARGE)
5317                 *p = 'l';
5318               else if (flag & SHF_MASKOS)
5319                 {
5320                   *p = 'o';
5321                   sh_flags &= ~ SHF_MASKOS;
5322                 }
5323               else if (flag & SHF_MASKPROC)
5324                 {
5325                   *p = 'p';
5326                   sh_flags &= ~ SHF_MASKPROC;
5327                 }
5328               else
5329                 *p = 'x';
5330               break;
5331             }
5332           p++;
5333         }
5334     }
5335
5336   if (do_section_details)
5337     {
5338       if (os_flags)
5339         {
5340           size -= 5 + field_size;
5341           if (p != buff + field_size + 4)
5342             {
5343               if (size < (2 + 1))
5344                 {
5345                   warn (_("Internal error: not enough buffer room for section flag info"));
5346                   return _("<unknown>");
5347                 }
5348               size -= 2;
5349               *p++ = ',';
5350               *p++ = ' ';
5351             }
5352           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5353                    (unsigned long) os_flags);
5354           p += 5 + field_size;
5355         }
5356       if (proc_flags)
5357         {
5358           size -= 7 + field_size;
5359           if (p != buff + field_size + 4)
5360             {
5361               if (size < (2 + 1))
5362                 {
5363                   warn (_("Internal error: not enough buffer room for section flag info"));
5364                   return _("<unknown>");
5365                 }
5366               size -= 2;
5367               *p++ = ',';
5368               *p++ = ' ';
5369             }
5370           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5371                    (unsigned long) proc_flags);
5372           p += 7 + field_size;
5373         }
5374       if (unknown_flags)
5375         {
5376           size -= 10 + field_size;
5377           if (p != buff + field_size + 4)
5378             {
5379               if (size < (2 + 1))
5380                 {
5381                   warn (_("Internal error: not enough buffer room for section flag info"));
5382                   return _("<unknown>");
5383                 }
5384               size -= 2;
5385               *p++ = ',';
5386               *p++ = ' ';
5387             }
5388           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5389                    (unsigned long) unknown_flags);
5390           p += 10 + field_size;
5391         }
5392     }
5393
5394   *p = '\0';
5395   return buff;
5396 }
5397
5398 static unsigned int
5399 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5400 {
5401   if (is_32bit_elf)
5402     {
5403       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5404       chdr->ch_type = BYTE_GET (echdr->ch_type);
5405       chdr->ch_size = BYTE_GET (echdr->ch_size);
5406       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5407       return sizeof (*echdr);
5408     }
5409   else
5410     {
5411       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5412       chdr->ch_type = BYTE_GET (echdr->ch_type);
5413       chdr->ch_size = BYTE_GET (echdr->ch_size);
5414       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5415       return sizeof (*echdr);
5416     }
5417 }
5418
5419 static int
5420 process_section_headers (FILE * file)
5421 {
5422   Elf_Internal_Shdr * section;
5423   unsigned int i;
5424
5425   section_headers = NULL;
5426
5427   if (elf_header.e_shnum == 0)
5428     {
5429       /* PR binutils/12467.  */
5430       if (elf_header.e_shoff != 0)
5431         warn (_("possibly corrupt ELF file header - it has a non-zero"
5432                 " section header offset, but no section headers\n"));
5433       else if (do_sections)
5434         printf (_("\nThere are no sections in this file.\n"));
5435
5436       return 1;
5437     }
5438
5439   if (do_sections && !do_header)
5440     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5441             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5442
5443   if (is_32bit_elf)
5444     {
5445       if (! get_32bit_section_headers (file, FALSE))
5446         return 0;
5447     }
5448   else if (! get_64bit_section_headers (file, FALSE))
5449     return 0;
5450
5451   /* Read in the string table, so that we have names to display.  */
5452   if (elf_header.e_shstrndx != SHN_UNDEF
5453        && elf_header.e_shstrndx < elf_header.e_shnum)
5454     {
5455       section = section_headers + elf_header.e_shstrndx;
5456
5457       if (section->sh_size != 0)
5458         {
5459           string_table = (char *) get_data (NULL, file, section->sh_offset,
5460                                             1, section->sh_size,
5461                                             _("string table"));
5462
5463           string_table_length = string_table != NULL ? section->sh_size : 0;
5464         }
5465     }
5466
5467   /* Scan the sections for the dynamic symbol table
5468      and dynamic string table and debug sections.  */
5469   dynamic_symbols = NULL;
5470   dynamic_strings = NULL;
5471   dynamic_syminfo = NULL;
5472   symtab_shndx_hdr = NULL;
5473
5474   eh_addr_size = is_32bit_elf ? 4 : 8;
5475   switch (elf_header.e_machine)
5476     {
5477     case EM_MIPS:
5478     case EM_MIPS_RS3_LE:
5479       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5480          FDE addresses.  However, the ABI also has a semi-official ILP32
5481          variant for which the normal FDE address size rules apply.
5482
5483          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5484          section, where XX is the size of longs in bits.  Unfortunately,
5485          earlier compilers provided no way of distinguishing ILP32 objects
5486          from LP64 objects, so if there's any doubt, we should assume that
5487          the official LP64 form is being used.  */
5488       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5489           && find_section (".gcc_compiled_long32") == NULL)
5490         eh_addr_size = 8;
5491       break;
5492
5493     case EM_H8_300:
5494     case EM_H8_300H:
5495       switch (elf_header.e_flags & EF_H8_MACH)
5496         {
5497         case E_H8_MACH_H8300:
5498         case E_H8_MACH_H8300HN:
5499         case E_H8_MACH_H8300SN:
5500         case E_H8_MACH_H8300SXN:
5501           eh_addr_size = 2;
5502           break;
5503         case E_H8_MACH_H8300H:
5504         case E_H8_MACH_H8300S:
5505         case E_H8_MACH_H8300SX:
5506           eh_addr_size = 4;
5507           break;
5508         }
5509       break;
5510
5511     case EM_M32C_OLD:
5512     case EM_M32C:
5513       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5514         {
5515         case EF_M32C_CPU_M16C:
5516           eh_addr_size = 2;
5517           break;
5518         }
5519       break;
5520     }
5521
5522 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5523   do                                                                    \
5524     {                                                                   \
5525       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5526       if (section->sh_entsize != expected_entsize)                      \
5527         {                                                               \
5528           char buf[40];                                                 \
5529           sprintf_vma (buf, section->sh_entsize);                       \
5530           /* Note: coded this way so that there is a single string for  \
5531              translation.  */ \
5532           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5533           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5534                    (unsigned) expected_entsize);                        \
5535           section->sh_entsize = expected_entsize;                       \
5536         }                                                               \
5537     }                                                                   \
5538   while (0)
5539
5540 #define CHECK_ENTSIZE(section, i, type)                                 \
5541   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5542                         sizeof (Elf64_External_##type))
5543
5544   for (i = 0, section = section_headers;
5545        i < elf_header.e_shnum;
5546        i++, section++)
5547     {
5548       char * name = SECTION_NAME (section);
5549
5550       if (section->sh_type == SHT_DYNSYM)
5551         {
5552           if (dynamic_symbols != NULL)
5553             {
5554               error (_("File contains multiple dynamic symbol tables\n"));
5555               continue;
5556             }
5557
5558           CHECK_ENTSIZE (section, i, Sym);
5559           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5560         }
5561       else if (section->sh_type == SHT_STRTAB
5562                && streq (name, ".dynstr"))
5563         {
5564           if (dynamic_strings != NULL)
5565             {
5566               error (_("File contains multiple dynamic string tables\n"));
5567               continue;
5568             }
5569
5570           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5571                                                1, section->sh_size,
5572                                                _("dynamic strings"));
5573           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5574         }
5575       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5576         {
5577           if (symtab_shndx_hdr != NULL)
5578             {
5579               error (_("File contains multiple symtab shndx tables\n"));
5580               continue;
5581             }
5582           symtab_shndx_hdr = section;
5583         }
5584       else if (section->sh_type == SHT_SYMTAB)
5585         CHECK_ENTSIZE (section, i, Sym);
5586       else if (section->sh_type == SHT_GROUP)
5587         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5588       else if (section->sh_type == SHT_REL)
5589         CHECK_ENTSIZE (section, i, Rel);
5590       else if (section->sh_type == SHT_RELA)
5591         CHECK_ENTSIZE (section, i, Rela);
5592       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5593                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5594                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5595                 || do_debug_str || do_debug_loc || do_debug_ranges
5596                 || do_debug_addr || do_debug_cu_index)
5597                && (const_strneq (name, ".debug_")
5598                    || const_strneq (name, ".zdebug_")))
5599         {
5600           if (name[1] == 'z')
5601             name += sizeof (".zdebug_") - 1;
5602           else
5603             name += sizeof (".debug_") - 1;
5604
5605           if (do_debugging
5606               || (do_debug_info     && const_strneq (name, "info"))
5607               || (do_debug_info     && const_strneq (name, "types"))
5608               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5609               || (do_debug_lines    && strcmp (name, "line") == 0)
5610               || (do_debug_lines    && const_strneq (name, "line."))
5611               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5612               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5613               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5614               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5615               || (do_debug_aranges  && const_strneq (name, "aranges"))
5616               || (do_debug_ranges   && const_strneq (name, "ranges"))
5617               || (do_debug_frames   && const_strneq (name, "frame"))
5618               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5619               || (do_debug_macinfo  && const_strneq (name, "macro"))
5620               || (do_debug_str      && const_strneq (name, "str"))
5621               || (do_debug_loc      && const_strneq (name, "loc"))
5622               || (do_debug_addr     && const_strneq (name, "addr"))
5623               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5624               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5625               )
5626             request_dump_bynumber (i, DEBUG_DUMP);
5627         }
5628       /* Linkonce section to be combined with .debug_info at link time.  */
5629       else if ((do_debugging || do_debug_info)
5630                && const_strneq (name, ".gnu.linkonce.wi."))
5631         request_dump_bynumber (i, DEBUG_DUMP);
5632       else if (do_debug_frames && streq (name, ".eh_frame"))
5633         request_dump_bynumber (i, DEBUG_DUMP);
5634       else if (do_gdb_index && streq (name, ".gdb_index"))
5635         request_dump_bynumber (i, DEBUG_DUMP);
5636       /* Trace sections for Itanium VMS.  */
5637       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5638                 || do_trace_aranges)
5639                && const_strneq (name, ".trace_"))
5640         {
5641           name += sizeof (".trace_") - 1;
5642
5643           if (do_debugging
5644               || (do_trace_info     && streq (name, "info"))
5645               || (do_trace_abbrevs  && streq (name, "abbrev"))
5646               || (do_trace_aranges  && streq (name, "aranges"))
5647               )
5648             request_dump_bynumber (i, DEBUG_DUMP);
5649         }
5650     }
5651
5652   if (! do_sections)
5653     return 1;
5654
5655   if (elf_header.e_shnum > 1)
5656     printf (_("\nSection Headers:\n"));
5657   else
5658     printf (_("\nSection Header:\n"));
5659
5660   if (is_32bit_elf)
5661     {
5662       if (do_section_details)
5663         {
5664           printf (_("  [Nr] Name\n"));
5665           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5666         }
5667       else
5668         printf
5669           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5670     }
5671   else if (do_wide)
5672     {
5673       if (do_section_details)
5674         {
5675           printf (_("  [Nr] Name\n"));
5676           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5677         }
5678       else
5679         printf
5680           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5681     }
5682   else
5683     {
5684       if (do_section_details)
5685         {
5686           printf (_("  [Nr] Name\n"));
5687           printf (_("       Type              Address          Offset            Link\n"));
5688           printf (_("       Size              EntSize          Info              Align\n"));
5689         }
5690       else
5691         {
5692           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5693           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5694         }
5695     }
5696
5697   if (do_section_details)
5698     printf (_("       Flags\n"));
5699
5700   for (i = 0, section = section_headers;
5701        i < elf_header.e_shnum;
5702        i++, section++)
5703     {
5704       printf ("  [%2u] ", i);
5705       if (do_section_details)
5706         printf ("%s\n      ", printable_section_name (section));
5707       else
5708         print_symbol (-17, SECTION_NAME (section));
5709
5710       printf (do_wide ? " %-15s " : " %-15.15s ",
5711               get_section_type_name (section->sh_type));
5712
5713       if (is_32bit_elf)
5714         {
5715           const char * link_too_big = NULL;
5716
5717           print_vma (section->sh_addr, LONG_HEX);
5718
5719           printf ( " %6.6lx %6.6lx %2.2lx",
5720                    (unsigned long) section->sh_offset,
5721                    (unsigned long) section->sh_size,
5722                    (unsigned long) section->sh_entsize);
5723
5724           if (do_section_details)
5725             fputs ("  ", stdout);
5726           else
5727             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5728
5729           if (section->sh_link >= elf_header.e_shnum)
5730             {
5731               link_too_big = "";
5732               /* The sh_link value is out of range.  Normally this indicates
5733                  an error but it can have special values in Solaris binaries.  */
5734               switch (elf_header.e_machine)
5735                 {
5736                 case EM_386:
5737                 case EM_486:
5738                 case EM_X86_64:
5739                 case EM_L1OM:
5740                 case EM_K1OM:
5741                 case EM_OLD_SPARCV9:
5742                 case EM_SPARC32PLUS:
5743                 case EM_SPARCV9:
5744                 case EM_SPARC:
5745                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5746                     link_too_big = "BEFORE";
5747                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5748                     link_too_big = "AFTER";
5749                   break;
5750                 default:
5751                   break;
5752                 }
5753             }
5754
5755           if (do_section_details)
5756             {
5757               if (link_too_big != NULL && * link_too_big)
5758                 printf ("<%s> ", link_too_big);
5759               else
5760                 printf ("%2u ", section->sh_link);
5761               printf ("%3u %2lu\n", section->sh_info,
5762                       (unsigned long) section->sh_addralign);
5763             }
5764           else
5765             printf ("%2u %3u %2lu\n",
5766                     section->sh_link,
5767                     section->sh_info,
5768                     (unsigned long) section->sh_addralign);
5769
5770           if (link_too_big && ! * link_too_big)
5771             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5772                   i, section->sh_link);
5773         }
5774       else if (do_wide)
5775         {
5776           print_vma (section->sh_addr, LONG_HEX);
5777
5778           if ((long) section->sh_offset == section->sh_offset)
5779             printf (" %6.6lx", (unsigned long) section->sh_offset);
5780           else
5781             {
5782               putchar (' ');
5783               print_vma (section->sh_offset, LONG_HEX);
5784             }
5785
5786           if ((unsigned long) section->sh_size == section->sh_size)
5787             printf (" %6.6lx", (unsigned long) section->sh_size);
5788           else
5789             {
5790               putchar (' ');
5791               print_vma (section->sh_size, LONG_HEX);
5792             }
5793
5794           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5795             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5796           else
5797             {
5798               putchar (' ');
5799               print_vma (section->sh_entsize, LONG_HEX);
5800             }
5801
5802           if (do_section_details)
5803             fputs ("  ", stdout);
5804           else
5805             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5806
5807           printf ("%2u %3u ", section->sh_link, section->sh_info);
5808
5809           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5810             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5811           else
5812             {
5813               print_vma (section->sh_addralign, DEC);
5814               putchar ('\n');
5815             }
5816         }
5817       else if (do_section_details)
5818         {
5819           printf ("       %-15.15s  ",
5820                   get_section_type_name (section->sh_type));
5821           print_vma (section->sh_addr, LONG_HEX);
5822           if ((long) section->sh_offset == section->sh_offset)
5823             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5824           else
5825             {
5826               printf ("  ");
5827               print_vma (section->sh_offset, LONG_HEX);
5828             }
5829           printf ("  %u\n       ", section->sh_link);
5830           print_vma (section->sh_size, LONG_HEX);
5831           putchar (' ');
5832           print_vma (section->sh_entsize, LONG_HEX);
5833
5834           printf ("  %-16u  %lu\n",
5835                   section->sh_info,
5836                   (unsigned long) section->sh_addralign);
5837         }
5838       else
5839         {
5840           putchar (' ');
5841           print_vma (section->sh_addr, LONG_HEX);
5842           if ((long) section->sh_offset == section->sh_offset)
5843             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5844           else
5845             {
5846               printf ("  ");
5847               print_vma (section->sh_offset, LONG_HEX);
5848             }
5849           printf ("\n       ");
5850           print_vma (section->sh_size, LONG_HEX);
5851           printf ("  ");
5852           print_vma (section->sh_entsize, LONG_HEX);
5853
5854           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5855
5856           printf ("     %2u   %3u     %lu\n",
5857                   section->sh_link,
5858                   section->sh_info,
5859                   (unsigned long) section->sh_addralign);
5860         }
5861
5862       if (do_section_details)
5863         {
5864           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5865           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5866             {
5867               /* Minimum section size is 12 bytes for 32-bit compression
5868                  header + 12 bytes for compressed data header.  */
5869               unsigned char buf[24];
5870               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5871               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5872                             sizeof (buf), _("compression header")))
5873                 {
5874                   Elf_Internal_Chdr chdr;
5875                   get_compression_header (&chdr, buf);
5876                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5877                     printf ("       ZLIB, ");
5878                   else
5879                     printf (_("       [<unknown>: 0x%x], "),
5880                             chdr.ch_type);
5881                   print_vma (chdr.ch_size, LONG_HEX);
5882                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5883                 }
5884             }
5885         }
5886     }
5887
5888   if (!do_section_details)
5889     {
5890       if (elf_header.e_machine == EM_X86_64
5891           || elf_header.e_machine == EM_L1OM
5892           || elf_header.e_machine == EM_K1OM)
5893         printf (_("Key to Flags:\n\
5894   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5895   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5896   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5897       else
5898         printf (_("Key to Flags:\n\
5899   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5900   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5901   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5902     }
5903
5904   return 1;
5905 }
5906
5907 static const char *
5908 get_group_flags (unsigned int flags)
5909 {
5910   static char buff[32];
5911   switch (flags)
5912     {
5913     case 0:
5914       return "";
5915
5916     case GRP_COMDAT:
5917       return "COMDAT ";
5918
5919    default:
5920       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5921       break;
5922     }
5923   return buff;
5924 }
5925
5926 static int
5927 process_section_groups (FILE * file)
5928 {
5929   Elf_Internal_Shdr * section;
5930   unsigned int i;
5931   struct group * group;
5932   Elf_Internal_Shdr * symtab_sec;
5933   Elf_Internal_Shdr * strtab_sec;
5934   Elf_Internal_Sym * symtab;
5935   unsigned long num_syms;
5936   char * strtab;
5937   size_t strtab_size;
5938
5939   /* Don't process section groups unless needed.  */
5940   if (!do_unwind && !do_section_groups)
5941     return 1;
5942
5943   if (elf_header.e_shnum == 0)
5944     {
5945       if (do_section_groups)
5946         printf (_("\nThere are no sections to group in this file.\n"));
5947
5948       return 1;
5949     }
5950
5951   if (section_headers == NULL)
5952     {
5953       error (_("Section headers are not available!\n"));
5954       /* PR 13622: This can happen with a corrupt ELF header.  */
5955       return 0;
5956     }
5957
5958   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5959                                                      sizeof (struct group *));
5960
5961   if (section_headers_groups == NULL)
5962     {
5963       error (_("Out of memory reading %u section group headers\n"),
5964              elf_header.e_shnum);
5965       return 0;
5966     }
5967
5968   /* Scan the sections for the group section.  */
5969   group_count = 0;
5970   for (i = 0, section = section_headers;
5971        i < elf_header.e_shnum;
5972        i++, section++)
5973     if (section->sh_type == SHT_GROUP)
5974       group_count++;
5975
5976   if (group_count == 0)
5977     {
5978       if (do_section_groups)
5979         printf (_("\nThere are no section groups in this file.\n"));
5980
5981       return 1;
5982     }
5983
5984   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5985
5986   if (section_groups == NULL)
5987     {
5988       error (_("Out of memory reading %lu groups\n"),
5989              (unsigned long) group_count);
5990       return 0;
5991     }
5992
5993   symtab_sec = NULL;
5994   strtab_sec = NULL;
5995   symtab = NULL;
5996   num_syms = 0;
5997   strtab = NULL;
5998   strtab_size = 0;
5999   for (i = 0, section = section_headers, group = section_groups;
6000        i < elf_header.e_shnum;
6001        i++, section++)
6002     {
6003       if (section->sh_type == SHT_GROUP)
6004         {
6005           const char * name = printable_section_name (section);
6006           const char * group_name;
6007           unsigned char * start;
6008           unsigned char * indices;
6009           unsigned int entry, j, size;
6010           Elf_Internal_Shdr * sec;
6011           Elf_Internal_Sym * sym;
6012
6013           /* Get the symbol table.  */
6014           if (section->sh_link >= elf_header.e_shnum
6015               || ((sec = section_headers + section->sh_link)->sh_type
6016                   != SHT_SYMTAB))
6017             {
6018               error (_("Bad sh_link in group section `%s'\n"), name);
6019               continue;
6020             }
6021
6022           if (symtab_sec != sec)
6023             {
6024               symtab_sec = sec;
6025               if (symtab)
6026                 free (symtab);
6027               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6028             }
6029
6030           if (symtab == NULL)
6031             {
6032               error (_("Corrupt header in group section `%s'\n"), name);
6033               continue;
6034             }
6035
6036           if (section->sh_info >= num_syms)
6037             {
6038               error (_("Bad sh_info in group section `%s'\n"), name);
6039               continue;
6040             }
6041
6042           sym = symtab + section->sh_info;
6043
6044           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6045             {
6046               if (sym->st_shndx == 0
6047                   || sym->st_shndx >= elf_header.e_shnum)
6048                 {
6049                   error (_("Bad sh_info in group section `%s'\n"), name);
6050                   continue;
6051                 }
6052
6053               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6054               strtab_sec = NULL;
6055               if (strtab)
6056                 free (strtab);
6057               strtab = NULL;
6058               strtab_size = 0;
6059             }
6060           else
6061             {
6062               /* Get the string table.  */
6063               if (symtab_sec->sh_link >= elf_header.e_shnum)
6064                 {
6065                   strtab_sec = NULL;
6066                   if (strtab)
6067                     free (strtab);
6068                   strtab = NULL;
6069                   strtab_size = 0;
6070                 }
6071               else if (strtab_sec
6072                        != (sec = section_headers + symtab_sec->sh_link))
6073                 {
6074                   strtab_sec = sec;
6075                   if (strtab)
6076                     free (strtab);
6077
6078                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6079                                               1, strtab_sec->sh_size,
6080                                               _("string table"));
6081                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6082                 }
6083               group_name = sym->st_name < strtab_size
6084                 ? strtab + sym->st_name : _("<corrupt>");
6085             }
6086
6087           /* PR 17531: file: loop.  */
6088           if (section->sh_entsize > section->sh_size)
6089             {
6090               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6091                      printable_section_name (section),
6092                      (unsigned long) section->sh_entsize,
6093                      (unsigned long) section->sh_size);
6094               break;
6095             }
6096
6097           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6098                                               1, section->sh_size,
6099                                               _("section data"));
6100           if (start == NULL)
6101             continue;
6102
6103           indices = start;
6104           size = (section->sh_size / section->sh_entsize) - 1;
6105           entry = byte_get (indices, 4);
6106           indices += 4;
6107
6108           if (do_section_groups)
6109             {
6110               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6111                       get_group_flags (entry), i, name, group_name, size);
6112
6113               printf (_("   [Index]    Name\n"));
6114             }
6115
6116           group->group_index = i;
6117
6118           for (j = 0; j < size; j++)
6119             {
6120               struct group_list * g;
6121
6122               entry = byte_get (indices, 4);
6123               indices += 4;
6124
6125               if (entry >= elf_header.e_shnum)
6126                 {
6127                   static unsigned num_group_errors = 0;
6128
6129                   if (num_group_errors ++ < 10)
6130                     {
6131                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6132                              entry, i, elf_header.e_shnum - 1);
6133                       if (num_group_errors == 10)
6134                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6135                     }
6136                   continue;
6137                 }
6138
6139               if (section_headers_groups [entry] != NULL)
6140                 {
6141                   if (entry)
6142                     {
6143                       static unsigned num_errs = 0;
6144
6145                       if (num_errs ++ < 10)
6146                         {
6147                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6148                                  entry, i,
6149                                  section_headers_groups [entry]->group_index);
6150                           if (num_errs == 10)
6151                             warn (_("Further error messages about already contained group sections suppressed\n"));
6152                         }
6153                       continue;
6154                     }
6155                   else
6156                     {
6157                       /* Intel C/C++ compiler may put section 0 in a
6158                          section group. We just warn it the first time
6159                          and ignore it afterwards.  */
6160                       static int warned = 0;
6161                       if (!warned)
6162                         {
6163                           error (_("section 0 in group section [%5u]\n"),
6164                                  section_headers_groups [entry]->group_index);
6165                           warned++;
6166                         }
6167                     }
6168                 }
6169
6170               section_headers_groups [entry] = group;
6171
6172               if (do_section_groups)
6173                 {
6174                   sec = section_headers + entry;
6175                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6176                 }
6177
6178               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6179               g->section_index = entry;
6180               g->next = group->root;
6181               group->root = g;
6182             }
6183
6184           if (start)
6185             free (start);
6186
6187           group++;
6188         }
6189     }
6190
6191   if (symtab)
6192     free (symtab);
6193   if (strtab)
6194     free (strtab);
6195   return 1;
6196 }
6197
6198 /* Data used to display dynamic fixups.  */
6199
6200 struct ia64_vms_dynfixup
6201 {
6202   bfd_vma needed_ident;         /* Library ident number.  */
6203   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6204   bfd_vma fixup_needed;         /* Index of the library.  */
6205   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6206   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6207 };
6208
6209 /* Data used to display dynamic relocations.  */
6210
6211 struct ia64_vms_dynimgrela
6212 {
6213   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6214   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6215 };
6216
6217 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6218    library).  */
6219
6220 static void
6221 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6222                               const char *strtab, unsigned int strtab_sz)
6223 {
6224   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6225   long i;
6226   const char *lib_name;
6227
6228   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6229                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6230                    _("dynamic section image fixups"));
6231   if (!imfs)
6232     return;
6233
6234   if (fixup->needed < strtab_sz)
6235     lib_name = strtab + fixup->needed;
6236   else
6237     {
6238       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6239             (unsigned long) fixup->needed);
6240       lib_name = "???";
6241     }
6242   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6243           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6244   printf
6245     (_("Seg Offset           Type                             SymVec DataType\n"));
6246
6247   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6248     {
6249       unsigned int type;
6250       const char *rtype;
6251
6252       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6253       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6254       type = BYTE_GET (imfs [i].type);
6255       rtype = elf_ia64_reloc_type (type);
6256       if (rtype == NULL)
6257         printf (" 0x%08x                       ", type);
6258       else
6259         printf (" %-32s ", rtype);
6260       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6261       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6262     }
6263
6264   free (imfs);
6265 }
6266
6267 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6268
6269 static void
6270 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6271 {
6272   Elf64_External_VMS_IMAGE_RELA *imrs;
6273   long i;
6274
6275   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6276                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6277                    _("dynamic section image relocations"));
6278   if (!imrs)
6279     return;
6280
6281   printf (_("\nImage relocs\n"));
6282   printf
6283     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6284
6285   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6286     {
6287       unsigned int type;
6288       const char *rtype;
6289
6290       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6291       printf ("%08" BFD_VMA_FMT "x ",
6292               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6293       type = BYTE_GET (imrs [i].type);
6294       rtype = elf_ia64_reloc_type (type);
6295       if (rtype == NULL)
6296         printf ("0x%08x                      ", type);
6297       else
6298         printf ("%-31s ", rtype);
6299       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6300       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6301       printf ("%08" BFD_VMA_FMT "x\n",
6302               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6303     }
6304
6305   free (imrs);
6306 }
6307
6308 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6309
6310 static int
6311 process_ia64_vms_dynamic_relocs (FILE *file)
6312 {
6313   struct ia64_vms_dynfixup fixup;
6314   struct ia64_vms_dynimgrela imgrela;
6315   Elf_Internal_Dyn *entry;
6316   int res = 0;
6317   bfd_vma strtab_off = 0;
6318   bfd_vma strtab_sz = 0;
6319   char *strtab = NULL;
6320
6321   memset (&fixup, 0, sizeof (fixup));
6322   memset (&imgrela, 0, sizeof (imgrela));
6323
6324   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6325   for (entry = dynamic_section;
6326        entry < dynamic_section + dynamic_nent;
6327        entry++)
6328     {
6329       switch (entry->d_tag)
6330         {
6331         case DT_IA_64_VMS_STRTAB_OFFSET:
6332           strtab_off = entry->d_un.d_val;
6333           break;
6334         case DT_STRSZ:
6335           strtab_sz = entry->d_un.d_val;
6336           if (strtab == NULL)
6337             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6338                                1, strtab_sz, _("dynamic string section"));
6339           break;
6340
6341         case DT_IA_64_VMS_NEEDED_IDENT:
6342           fixup.needed_ident = entry->d_un.d_val;
6343           break;
6344         case DT_NEEDED:
6345           fixup.needed = entry->d_un.d_val;
6346           break;
6347         case DT_IA_64_VMS_FIXUP_NEEDED:
6348           fixup.fixup_needed = entry->d_un.d_val;
6349           break;
6350         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6351           fixup.fixup_rela_cnt = entry->d_un.d_val;
6352           break;
6353         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6354           fixup.fixup_rela_off = entry->d_un.d_val;
6355           res++;
6356           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6357           break;
6358
6359         case DT_IA_64_VMS_IMG_RELA_CNT:
6360           imgrela.img_rela_cnt = entry->d_un.d_val;
6361           break;
6362         case DT_IA_64_VMS_IMG_RELA_OFF:
6363           imgrela.img_rela_off = entry->d_un.d_val;
6364           res++;
6365           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6366           break;
6367
6368         default:
6369           break;
6370         }
6371     }
6372
6373   if (strtab != NULL)
6374     free (strtab);
6375
6376   return res;
6377 }
6378
6379 static struct
6380 {
6381   const char * name;
6382   int reloc;
6383   int size;
6384   int rela;
6385 } dynamic_relocations [] =
6386 {
6387     { "REL", DT_REL, DT_RELSZ, FALSE },
6388     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6389     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6390 };
6391
6392 /* Process the reloc section.  */
6393
6394 static int
6395 process_relocs (FILE * file)
6396 {
6397   unsigned long rel_size;
6398   unsigned long rel_offset;
6399
6400
6401   if (!do_reloc)
6402     return 1;
6403
6404   if (do_using_dynamic)
6405     {
6406       int is_rela;
6407       const char * name;
6408       int has_dynamic_reloc;
6409       unsigned int i;
6410
6411       has_dynamic_reloc = 0;
6412
6413       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6414         {
6415           is_rela = dynamic_relocations [i].rela;
6416           name = dynamic_relocations [i].name;
6417           rel_size = dynamic_info [dynamic_relocations [i].size];
6418           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6419
6420           has_dynamic_reloc |= rel_size;
6421
6422           if (is_rela == UNKNOWN)
6423             {
6424               if (dynamic_relocations [i].reloc == DT_JMPREL)
6425                 switch (dynamic_info[DT_PLTREL])
6426                   {
6427                   case DT_REL:
6428                     is_rela = FALSE;
6429                     break;
6430                   case DT_RELA:
6431                     is_rela = TRUE;
6432                     break;
6433                   }
6434             }
6435
6436           if (rel_size)
6437             {
6438               printf
6439                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6440                  name, rel_offset, rel_size);
6441
6442               dump_relocations (file,
6443                                 offset_from_vma (file, rel_offset, rel_size),
6444                                 rel_size,
6445                                 dynamic_symbols, num_dynamic_syms,
6446                                 dynamic_strings, dynamic_strings_length,
6447                                 is_rela, 1);
6448             }
6449         }
6450
6451       if (is_ia64_vms ())
6452         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6453
6454       if (! has_dynamic_reloc)
6455         printf (_("\nThere are no dynamic relocations in this file.\n"));
6456     }
6457   else
6458     {
6459       Elf_Internal_Shdr * section;
6460       unsigned long i;
6461       int found = 0;
6462
6463       for (i = 0, section = section_headers;
6464            i < elf_header.e_shnum;
6465            i++, section++)
6466         {
6467           if (   section->sh_type != SHT_RELA
6468               && section->sh_type != SHT_REL)
6469             continue;
6470
6471           rel_offset = section->sh_offset;
6472           rel_size   = section->sh_size;
6473
6474           if (rel_size)
6475             {
6476               Elf_Internal_Shdr * strsec;
6477               int is_rela;
6478
6479               printf (_("\nRelocation section "));
6480
6481               if (string_table == NULL)
6482                 printf ("%d", section->sh_name);
6483               else
6484                 printf ("'%s'", printable_section_name (section));
6485
6486               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6487                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6488
6489               is_rela = section->sh_type == SHT_RELA;
6490
6491               if (section->sh_link != 0
6492                   && section->sh_link < elf_header.e_shnum)
6493                 {
6494                   Elf_Internal_Shdr * symsec;
6495                   Elf_Internal_Sym *  symtab;
6496                   unsigned long nsyms;
6497                   unsigned long strtablen = 0;
6498                   char * strtab = NULL;
6499
6500                   symsec = section_headers + section->sh_link;
6501                   if (symsec->sh_type != SHT_SYMTAB
6502                       && symsec->sh_type != SHT_DYNSYM)
6503                     continue;
6504
6505                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6506
6507                   if (symtab == NULL)
6508                     continue;
6509
6510                   if (symsec->sh_link != 0
6511                       && symsec->sh_link < elf_header.e_shnum)
6512                     {
6513                       strsec = section_headers + symsec->sh_link;
6514
6515                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6516                                                   1, strsec->sh_size,
6517                                                   _("string table"));
6518                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6519                     }
6520
6521                   dump_relocations (file, rel_offset, rel_size,
6522                                     symtab, nsyms, strtab, strtablen,
6523                                     is_rela,
6524                                     symsec->sh_type == SHT_DYNSYM);
6525                   if (strtab)
6526                     free (strtab);
6527                   free (symtab);
6528                 }
6529               else
6530                 dump_relocations (file, rel_offset, rel_size,
6531                                   NULL, 0, NULL, 0, is_rela, 0);
6532
6533               found = 1;
6534             }
6535         }
6536
6537       if (! found)
6538         printf (_("\nThere are no relocations in this file.\n"));
6539     }
6540
6541   return 1;
6542 }
6543
6544 /* An absolute address consists of a section and an offset.  If the
6545    section is NULL, the offset itself is the address, otherwise, the
6546    address equals to LOAD_ADDRESS(section) + offset.  */
6547
6548 struct absaddr
6549 {
6550   unsigned short section;
6551   bfd_vma offset;
6552 };
6553
6554 #define ABSADDR(a) \
6555   ((a).section \
6556    ? section_headers [(a).section].sh_addr + (a).offset \
6557    : (a).offset)
6558
6559 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6560    name, if found, and the offset from the symbol to ADDR.  */
6561
6562 static void
6563 find_symbol_for_address (Elf_Internal_Sym * symtab,
6564                          unsigned long      nsyms,
6565                          const char *       strtab,
6566                          unsigned long      strtab_size,
6567                          struct absaddr     addr,
6568                          const char **      symname,
6569                          bfd_vma *          offset)
6570 {
6571   bfd_vma dist = 0x100000;
6572   Elf_Internal_Sym * sym;
6573   Elf_Internal_Sym * beg;
6574   Elf_Internal_Sym * end;
6575   Elf_Internal_Sym * best = NULL;
6576
6577   REMOVE_ARCH_BITS (addr.offset);
6578   beg = symtab;
6579   end = symtab + nsyms;
6580
6581   while (beg < end)
6582     {
6583       bfd_vma value;
6584
6585       sym = beg + (end - beg) / 2;
6586
6587       value = sym->st_value;
6588       REMOVE_ARCH_BITS (value);
6589
6590       if (sym->st_name != 0
6591           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6592           && addr.offset >= value
6593           && addr.offset - value < dist)
6594         {
6595           best = sym;
6596           dist = addr.offset - value;
6597           if (!dist)
6598             break;
6599         }
6600
6601       if (addr.offset < value)
6602         end = sym;
6603       else
6604         beg = sym + 1;
6605     }
6606
6607   if (best)
6608     {
6609       *symname = (best->st_name >= strtab_size
6610                   ? _("<corrupt>") : strtab + best->st_name);
6611       *offset = dist;
6612       return;
6613     }
6614
6615   *symname = NULL;
6616   *offset = addr.offset;
6617 }
6618
6619 static int
6620 symcmp (const void *p, const void *q)
6621 {
6622   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6623   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6624
6625   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6626 }
6627
6628 /* Process the unwind section.  */
6629
6630 #include "unwind-ia64.h"
6631
6632 struct ia64_unw_table_entry
6633 {
6634   struct absaddr start;
6635   struct absaddr end;
6636   struct absaddr info;
6637 };
6638
6639 struct ia64_unw_aux_info
6640 {
6641   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6642   unsigned long table_len;              /* Length of unwind table.  */
6643   unsigned char * info;                 /* Unwind info.  */
6644   unsigned long info_size;              /* Size of unwind info.  */
6645   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6646   bfd_vma seg_base;                     /* Starting address of segment.  */
6647   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6648   unsigned long nsyms;                  /* Number of symbols.  */
6649   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6650   unsigned long nfuns;                  /* Number of entries in funtab.  */
6651   char * strtab;                        /* The string table.  */
6652   unsigned long strtab_size;            /* Size of string table.  */
6653 };
6654
6655 static void
6656 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6657 {
6658   struct ia64_unw_table_entry * tp;
6659   unsigned long j, nfuns;
6660   int in_body;
6661
6662   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6663   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6664     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6665       aux->funtab[nfuns++] = aux->symtab[j];
6666   aux->nfuns = nfuns;
6667   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6668
6669   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6670     {
6671       bfd_vma stamp;
6672       bfd_vma offset;
6673       const unsigned char * dp;
6674       const unsigned char * head;
6675       const unsigned char * end;
6676       const char * procname;
6677
6678       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6679                                aux->strtab_size, tp->start, &procname, &offset);
6680
6681       fputs ("\n<", stdout);
6682
6683       if (procname)
6684         {
6685           fputs (procname, stdout);
6686
6687           if (offset)
6688             printf ("+%lx", (unsigned long) offset);
6689         }
6690
6691       fputs (">: [", stdout);
6692       print_vma (tp->start.offset, PREFIX_HEX);
6693       fputc ('-', stdout);
6694       print_vma (tp->end.offset, PREFIX_HEX);
6695       printf ("], info at +0x%lx\n",
6696               (unsigned long) (tp->info.offset - aux->seg_base));
6697
6698       /* PR 17531: file: 86232b32.  */
6699       if (aux->info == NULL)
6700         continue;
6701
6702       /* PR 17531: file: 0997b4d1.  */
6703       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6704         {
6705           warn (_("Invalid offset %lx in table entry %ld\n"),
6706                 (long) tp->info.offset, (long) (tp - aux->table));
6707           continue;
6708         }
6709
6710       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6711       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6712
6713       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6714               (unsigned) UNW_VER (stamp),
6715               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6716               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6717               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6718               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6719
6720       if (UNW_VER (stamp) != 1)
6721         {
6722           printf (_("\tUnknown version.\n"));
6723           continue;
6724         }
6725
6726       in_body = 0;
6727       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6728       /* PR 17531: file: 16ceda89.  */
6729       if (end > aux->info + aux->info_size)
6730         end = aux->info + aux->info_size;
6731       for (dp = head + 8; dp < end;)
6732         dp = unw_decode (dp, in_body, & in_body);
6733     }
6734
6735   free (aux->funtab);
6736 }
6737
6738 static bfd_boolean
6739 slurp_ia64_unwind_table (FILE * file,
6740                          struct ia64_unw_aux_info * aux,
6741                          Elf_Internal_Shdr * sec)
6742 {
6743   unsigned long size, nrelas, i;
6744   Elf_Internal_Phdr * seg;
6745   struct ia64_unw_table_entry * tep;
6746   Elf_Internal_Shdr * relsec;
6747   Elf_Internal_Rela * rela;
6748   Elf_Internal_Rela * rp;
6749   unsigned char * table;
6750   unsigned char * tp;
6751   Elf_Internal_Sym * sym;
6752   const char * relname;
6753
6754   aux->table_len = 0;
6755
6756   /* First, find the starting address of the segment that includes
6757      this section: */
6758
6759   if (elf_header.e_phnum)
6760     {
6761       if (! get_program_headers (file))
6762           return FALSE;
6763
6764       for (seg = program_headers;
6765            seg < program_headers + elf_header.e_phnum;
6766            ++seg)
6767         {
6768           if (seg->p_type != PT_LOAD)
6769             continue;
6770
6771           if (sec->sh_addr >= seg->p_vaddr
6772               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6773             {
6774               aux->seg_base = seg->p_vaddr;
6775               break;
6776             }
6777         }
6778     }
6779
6780   /* Second, build the unwind table from the contents of the unwind section:  */
6781   size = sec->sh_size;
6782   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6783                                       _("unwind table"));
6784   if (!table)
6785     return FALSE;
6786
6787   aux->table_len = size / (3 * eh_addr_size);
6788   aux->table = (struct ia64_unw_table_entry *)
6789     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6790   tep = aux->table;
6791
6792   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6793     {
6794       tep->start.section = SHN_UNDEF;
6795       tep->end.section   = SHN_UNDEF;
6796       tep->info.section  = SHN_UNDEF;
6797       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6798       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6799       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6800       tep->start.offset += aux->seg_base;
6801       tep->end.offset   += aux->seg_base;
6802       tep->info.offset  += aux->seg_base;
6803     }
6804   free (table);
6805
6806   /* Third, apply any relocations to the unwind table:  */
6807   for (relsec = section_headers;
6808        relsec < section_headers + elf_header.e_shnum;
6809        ++relsec)
6810     {
6811       if (relsec->sh_type != SHT_RELA
6812           || relsec->sh_info >= elf_header.e_shnum
6813           || section_headers + relsec->sh_info != sec)
6814         continue;
6815
6816       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6817                               & rela, & nrelas))
6818         {
6819           free (aux->table);
6820           aux->table = NULL;
6821           aux->table_len = 0;
6822           return FALSE;
6823         }
6824
6825       for (rp = rela; rp < rela + nrelas; ++rp)
6826         {
6827           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6828           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6829
6830           /* PR 17531: file: 9fa67536.  */
6831           if (relname == NULL)
6832             {
6833               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6834               continue;
6835             }
6836
6837           if (! const_strneq (relname, "R_IA64_SEGREL"))
6838             {
6839               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6840               continue;
6841             }
6842
6843           i = rp->r_offset / (3 * eh_addr_size);
6844
6845           /* PR 17531: file: 5bc8d9bf.  */
6846           if (i >= aux->table_len)
6847             {
6848               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6849               continue;
6850             }
6851
6852           switch (rp->r_offset / eh_addr_size % 3)
6853             {
6854             case 0:
6855               aux->table[i].start.section = sym->st_shndx;
6856               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6857               break;
6858             case 1:
6859               aux->table[i].end.section   = sym->st_shndx;
6860               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6861               break;
6862             case 2:
6863               aux->table[i].info.section  = sym->st_shndx;
6864               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6865               break;
6866             default:
6867               break;
6868             }
6869         }
6870
6871       free (rela);
6872     }
6873
6874   return TRUE;
6875 }
6876
6877 static void
6878 ia64_process_unwind (FILE * file)
6879 {
6880   Elf_Internal_Shdr * sec;
6881   Elf_Internal_Shdr * unwsec = NULL;
6882   Elf_Internal_Shdr * strsec;
6883   unsigned long i, unwcount = 0, unwstart = 0;
6884   struct ia64_unw_aux_info aux;
6885
6886   memset (& aux, 0, sizeof (aux));
6887
6888   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6889     {
6890       if (sec->sh_type == SHT_SYMTAB
6891           && sec->sh_link < elf_header.e_shnum)
6892         {
6893           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6894
6895           strsec = section_headers + sec->sh_link;
6896           if (aux.strtab != NULL)
6897             {
6898               error (_("Multiple auxillary string tables encountered\n"));
6899               free (aux.strtab);
6900             }
6901           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6902                                           1, strsec->sh_size,
6903                                           _("string table"));
6904           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6905         }
6906       else if (sec->sh_type == SHT_IA_64_UNWIND)
6907         unwcount++;
6908     }
6909
6910   if (!unwcount)
6911     printf (_("\nThere are no unwind sections in this file.\n"));
6912
6913   while (unwcount-- > 0)
6914     {
6915       char * suffix;
6916       size_t len, len2;
6917
6918       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6919            i < elf_header.e_shnum; ++i, ++sec)
6920         if (sec->sh_type == SHT_IA_64_UNWIND)
6921           {
6922             unwsec = sec;
6923             break;
6924           }
6925       /* We have already counted the number of SHT_IA64_UNWIND
6926          sections so the loop above should never fail.  */
6927       assert (unwsec != NULL);
6928
6929       unwstart = i + 1;
6930       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6931
6932       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6933         {
6934           /* We need to find which section group it is in.  */
6935           struct group_list * g;
6936
6937           if (section_headers_groups == NULL
6938               || section_headers_groups [i] == NULL)
6939             i = elf_header.e_shnum;
6940           else
6941             {
6942               g = section_headers_groups [i]->root;
6943
6944               for (; g != NULL; g = g->next)
6945                 {
6946                   sec = section_headers + g->section_index;
6947
6948                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6949                     break;
6950                 }
6951
6952               if (g == NULL)
6953                 i = elf_header.e_shnum;
6954             }
6955         }
6956       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6957         {
6958           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6959           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6960           suffix = SECTION_NAME (unwsec) + len;
6961           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6962                ++i, ++sec)
6963             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6964                 && streq (SECTION_NAME (sec) + len2, suffix))
6965               break;
6966         }
6967       else
6968         {
6969           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6970              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6971           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6972           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6973           suffix = "";
6974           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6975             suffix = SECTION_NAME (unwsec) + len;
6976           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6977                ++i, ++sec)
6978             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6979                 && streq (SECTION_NAME (sec) + len2, suffix))
6980               break;
6981         }
6982
6983       if (i == elf_header.e_shnum)
6984         {
6985           printf (_("\nCould not find unwind info section for "));
6986
6987           if (string_table == NULL)
6988             printf ("%d", unwsec->sh_name);
6989           else
6990             printf ("'%s'", printable_section_name (unwsec));
6991         }
6992       else
6993         {
6994           aux.info_addr = sec->sh_addr;
6995           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6996                                                  sec->sh_size,
6997                                                  _("unwind info"));
6998           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6999
7000           printf (_("\nUnwind section "));
7001
7002           if (string_table == NULL)
7003             printf ("%d", unwsec->sh_name);
7004           else
7005             printf ("'%s'", printable_section_name (unwsec));
7006
7007           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7008                   (unsigned long) unwsec->sh_offset,
7009                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7010
7011           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7012               && aux.table_len > 0)
7013             dump_ia64_unwind (& aux);
7014
7015           if (aux.table)
7016             free ((char *) aux.table);
7017           if (aux.info)
7018             free ((char *) aux.info);
7019           aux.table = NULL;
7020           aux.info = NULL;
7021         }
7022     }
7023
7024   if (aux.symtab)
7025     free (aux.symtab);
7026   if (aux.strtab)
7027     free ((char *) aux.strtab);
7028 }
7029
7030 struct hppa_unw_table_entry
7031   {
7032     struct absaddr start;
7033     struct absaddr end;
7034     unsigned int Cannot_unwind:1;               /* 0 */
7035     unsigned int Millicode:1;                   /* 1 */
7036     unsigned int Millicode_save_sr0:1;          /* 2 */
7037     unsigned int Region_description:2;          /* 3..4 */
7038     unsigned int reserved1:1;                   /* 5 */
7039     unsigned int Entry_SR:1;                    /* 6 */
7040     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7041     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7042     unsigned int Args_stored:1;                 /* 16 */
7043     unsigned int Variable_Frame:1;              /* 17 */
7044     unsigned int Separate_Package_Body:1;       /* 18 */
7045     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7046     unsigned int Stack_Overflow_Check:1;        /* 20 */
7047     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7048     unsigned int Ada_Region:1;                  /* 22 */
7049     unsigned int cxx_info:1;                    /* 23 */
7050     unsigned int cxx_try_catch:1;               /* 24 */
7051     unsigned int sched_entry_seq:1;             /* 25 */
7052     unsigned int reserved2:1;                   /* 26 */
7053     unsigned int Save_SP:1;                     /* 27 */
7054     unsigned int Save_RP:1;                     /* 28 */
7055     unsigned int Save_MRP_in_frame:1;           /* 29 */
7056     unsigned int extn_ptr_defined:1;            /* 30 */
7057     unsigned int Cleanup_defined:1;             /* 31 */
7058
7059     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7060     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7061     unsigned int Large_frame:1;                 /* 2 */
7062     unsigned int Pseudo_SP_Set:1;               /* 3 */
7063     unsigned int reserved4:1;                   /* 4 */
7064     unsigned int Total_frame_size:27;           /* 5..31 */
7065   };
7066
7067 struct hppa_unw_aux_info
7068 {
7069   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7070   unsigned long table_len;              /* Length of unwind table.  */
7071   bfd_vma seg_base;                     /* Starting address of segment.  */
7072   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7073   unsigned long nsyms;                  /* Number of symbols.  */
7074   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7075   unsigned long nfuns;                  /* Number of entries in funtab.  */
7076   char * strtab;                        /* The string table.  */
7077   unsigned long strtab_size;            /* Size of string table.  */
7078 };
7079
7080 static void
7081 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7082 {
7083   struct hppa_unw_table_entry * tp;
7084   unsigned long j, nfuns;
7085
7086   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7087   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7088     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7089       aux->funtab[nfuns++] = aux->symtab[j];
7090   aux->nfuns = nfuns;
7091   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7092
7093   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7094     {
7095       bfd_vma offset;
7096       const char * procname;
7097
7098       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7099                                aux->strtab_size, tp->start, &procname,
7100                                &offset);
7101
7102       fputs ("\n<", stdout);
7103
7104       if (procname)
7105         {
7106           fputs (procname, stdout);
7107
7108           if (offset)
7109             printf ("+%lx", (unsigned long) offset);
7110         }
7111
7112       fputs (">: [", stdout);
7113       print_vma (tp->start.offset, PREFIX_HEX);
7114       fputc ('-', stdout);
7115       print_vma (tp->end.offset, PREFIX_HEX);
7116       printf ("]\n\t");
7117
7118 #define PF(_m) if (tp->_m) printf (#_m " ");
7119 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7120       PF(Cannot_unwind);
7121       PF(Millicode);
7122       PF(Millicode_save_sr0);
7123       /* PV(Region_description);  */
7124       PF(Entry_SR);
7125       PV(Entry_FR);
7126       PV(Entry_GR);
7127       PF(Args_stored);
7128       PF(Variable_Frame);
7129       PF(Separate_Package_Body);
7130       PF(Frame_Extension_Millicode);
7131       PF(Stack_Overflow_Check);
7132       PF(Two_Instruction_SP_Increment);
7133       PF(Ada_Region);
7134       PF(cxx_info);
7135       PF(cxx_try_catch);
7136       PF(sched_entry_seq);
7137       PF(Save_SP);
7138       PF(Save_RP);
7139       PF(Save_MRP_in_frame);
7140       PF(extn_ptr_defined);
7141       PF(Cleanup_defined);
7142       PF(MPE_XL_interrupt_marker);
7143       PF(HP_UX_interrupt_marker);
7144       PF(Large_frame);
7145       PF(Pseudo_SP_Set);
7146       PV(Total_frame_size);
7147 #undef PF
7148 #undef PV
7149     }
7150
7151   printf ("\n");
7152
7153   free (aux->funtab);
7154 }
7155
7156 static int
7157 slurp_hppa_unwind_table (FILE * file,
7158                          struct hppa_unw_aux_info * aux,
7159                          Elf_Internal_Shdr * sec)
7160 {
7161   unsigned long size, unw_ent_size, nentries, nrelas, i;
7162   Elf_Internal_Phdr * seg;
7163   struct hppa_unw_table_entry * tep;
7164   Elf_Internal_Shdr * relsec;
7165   Elf_Internal_Rela * rela;
7166   Elf_Internal_Rela * rp;
7167   unsigned char * table;
7168   unsigned char * tp;
7169   Elf_Internal_Sym * sym;
7170   const char * relname;
7171
7172   /* First, find the starting address of the segment that includes
7173      this section.  */
7174
7175   if (elf_header.e_phnum)
7176     {
7177       if (! get_program_headers (file))
7178         return 0;
7179
7180       for (seg = program_headers;
7181            seg < program_headers + elf_header.e_phnum;
7182            ++seg)
7183         {
7184           if (seg->p_type != PT_LOAD)
7185             continue;
7186
7187           if (sec->sh_addr >= seg->p_vaddr
7188               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7189             {
7190               aux->seg_base = seg->p_vaddr;
7191               break;
7192             }
7193         }
7194     }
7195
7196   /* Second, build the unwind table from the contents of the unwind
7197      section.  */
7198   size = sec->sh_size;
7199   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7200                                       _("unwind table"));
7201   if (!table)
7202     return 0;
7203
7204   unw_ent_size = 16;
7205   nentries = size / unw_ent_size;
7206   size = unw_ent_size * nentries;
7207
7208   tep = aux->table = (struct hppa_unw_table_entry *)
7209       xcmalloc (nentries, sizeof (aux->table[0]));
7210
7211   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7212     {
7213       unsigned int tmp1, tmp2;
7214
7215       tep->start.section = SHN_UNDEF;
7216       tep->end.section   = SHN_UNDEF;
7217
7218       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7219       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7220       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7221       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7222
7223       tep->start.offset += aux->seg_base;
7224       tep->end.offset   += aux->seg_base;
7225
7226       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7227       tep->Millicode = (tmp1 >> 30) & 0x1;
7228       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7229       tep->Region_description = (tmp1 >> 27) & 0x3;
7230       tep->reserved1 = (tmp1 >> 26) & 0x1;
7231       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7232       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7233       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7234       tep->Args_stored = (tmp1 >> 15) & 0x1;
7235       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7236       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7237       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7238       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7239       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7240       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7241       tep->cxx_info = (tmp1 >> 8) & 0x1;
7242       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7243       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7244       tep->reserved2 = (tmp1 >> 5) & 0x1;
7245       tep->Save_SP = (tmp1 >> 4) & 0x1;
7246       tep->Save_RP = (tmp1 >> 3) & 0x1;
7247       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7248       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7249       tep->Cleanup_defined = tmp1 & 0x1;
7250
7251       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7252       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7253       tep->Large_frame = (tmp2 >> 29) & 0x1;
7254       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7255       tep->reserved4 = (tmp2 >> 27) & 0x1;
7256       tep->Total_frame_size = tmp2 & 0x7ffffff;
7257     }
7258   free (table);
7259
7260   /* Third, apply any relocations to the unwind table.  */
7261   for (relsec = section_headers;
7262        relsec < section_headers + elf_header.e_shnum;
7263        ++relsec)
7264     {
7265       if (relsec->sh_type != SHT_RELA
7266           || relsec->sh_info >= elf_header.e_shnum
7267           || section_headers + relsec->sh_info != sec)
7268         continue;
7269
7270       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7271                               & rela, & nrelas))
7272         return 0;
7273
7274       for (rp = rela; rp < rela + nrelas; ++rp)
7275         {
7276           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7277           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7278
7279           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7280           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7281             {
7282               warn (_("Skipping unexpected relocation type %s\n"), relname);
7283               continue;
7284             }
7285
7286           i = rp->r_offset / unw_ent_size;
7287
7288           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7289             {
7290             case 0:
7291               aux->table[i].start.section = sym->st_shndx;
7292               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7293               break;
7294             case 1:
7295               aux->table[i].end.section   = sym->st_shndx;
7296               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7297               break;
7298             default:
7299               break;
7300             }
7301         }
7302
7303       free (rela);
7304     }
7305
7306   aux->table_len = nentries;
7307
7308   return 1;
7309 }
7310
7311 static void
7312 hppa_process_unwind (FILE * file)
7313 {
7314   struct hppa_unw_aux_info aux;
7315   Elf_Internal_Shdr * unwsec = NULL;
7316   Elf_Internal_Shdr * strsec;
7317   Elf_Internal_Shdr * sec;
7318   unsigned long i;
7319
7320   if (string_table == NULL)
7321     return;
7322
7323   memset (& aux, 0, sizeof (aux));
7324
7325   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7326     {
7327       if (sec->sh_type == SHT_SYMTAB
7328           && sec->sh_link < elf_header.e_shnum)
7329         {
7330           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7331
7332           strsec = section_headers + sec->sh_link;
7333           if (aux.strtab != NULL)
7334             {
7335               error (_("Multiple auxillary string tables encountered\n"));
7336               free (aux.strtab);
7337             }
7338           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7339                                           1, strsec->sh_size,
7340                                           _("string table"));
7341           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7342         }
7343       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7344         unwsec = sec;
7345     }
7346
7347   if (!unwsec)
7348     printf (_("\nThere are no unwind sections in this file.\n"));
7349
7350   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7351     {
7352       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7353         {
7354           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7355                   printable_section_name (sec),
7356                   (unsigned long) sec->sh_offset,
7357                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7358
7359           slurp_hppa_unwind_table (file, &aux, sec);
7360           if (aux.table_len > 0)
7361             dump_hppa_unwind (&aux);
7362
7363           if (aux.table)
7364             free ((char *) aux.table);
7365           aux.table = NULL;
7366         }
7367     }
7368
7369   if (aux.symtab)
7370     free (aux.symtab);
7371   if (aux.strtab)
7372     free ((char *) aux.strtab);
7373 }
7374
7375 struct arm_section
7376 {
7377   unsigned char *      data;            /* The unwind data.  */
7378   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7379   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7380   unsigned long        nrelas;          /* The number of relocations.  */
7381   unsigned int         rel_type;        /* REL or RELA ?  */
7382   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7383 };
7384
7385 struct arm_unw_aux_info
7386 {
7387   FILE *              file;             /* The file containing the unwind sections.  */
7388   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7389   unsigned long       nsyms;            /* Number of symbols.  */
7390   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7391   unsigned long       nfuns;            /* Number of these symbols.  */
7392   char *              strtab;           /* The file's string table.  */
7393   unsigned long       strtab_size;      /* Size of string table.  */
7394 };
7395
7396 static const char *
7397 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7398                         bfd_vma fn, struct absaddr addr)
7399 {
7400   const char *procname;
7401   bfd_vma sym_offset;
7402
7403   if (addr.section == SHN_UNDEF)
7404     addr.offset = fn;
7405
7406   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7407                            aux->strtab_size, addr, &procname,
7408                            &sym_offset);
7409
7410   print_vma (fn, PREFIX_HEX);
7411
7412   if (procname)
7413     {
7414       fputs (" <", stdout);
7415       fputs (procname, stdout);
7416
7417       if (sym_offset)
7418         printf ("+0x%lx", (unsigned long) sym_offset);
7419       fputc ('>', stdout);
7420     }
7421
7422   return procname;
7423 }
7424
7425 static void
7426 arm_free_section (struct arm_section *arm_sec)
7427 {
7428   if (arm_sec->data != NULL)
7429     free (arm_sec->data);
7430
7431   if (arm_sec->rela != NULL)
7432     free (arm_sec->rela);
7433 }
7434
7435 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7436       cached section and install SEC instead.
7437    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7438       and return its valued in * WORDP, relocating if necessary.
7439    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7440       relocation's offset in ADDR.
7441    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7442       into the string table of the symbol associated with the reloc.  If no
7443       reloc was applied store -1 there.
7444    5) Return TRUE upon success, FALSE otherwise.  */
7445
7446 static bfd_boolean
7447 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7448                          struct arm_section *       arm_sec,
7449                          Elf_Internal_Shdr *        sec,
7450                          bfd_vma                    word_offset,
7451                          unsigned int *             wordp,
7452                          struct absaddr *           addr,
7453                          bfd_vma *                  sym_name)
7454 {
7455   Elf_Internal_Rela *rp;
7456   Elf_Internal_Sym *sym;
7457   const char * relname;
7458   unsigned int word;
7459   bfd_boolean wrapped;
7460
7461   if (sec == NULL || arm_sec == NULL)
7462     return FALSE;
7463
7464   addr->section = SHN_UNDEF;
7465   addr->offset = 0;
7466
7467   if (sym_name != NULL)
7468     *sym_name = (bfd_vma) -1;
7469
7470   /* If necessary, update the section cache.  */
7471   if (sec != arm_sec->sec)
7472     {
7473       Elf_Internal_Shdr *relsec;
7474
7475       arm_free_section (arm_sec);
7476
7477       arm_sec->sec = sec;
7478       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7479                                 sec->sh_size, _("unwind data"));
7480       arm_sec->rela = NULL;
7481       arm_sec->nrelas = 0;
7482
7483       for (relsec = section_headers;
7484            relsec < section_headers + elf_header.e_shnum;
7485            ++relsec)
7486         {
7487           if (relsec->sh_info >= elf_header.e_shnum
7488               || section_headers + relsec->sh_info != sec
7489               /* PR 15745: Check the section type as well.  */
7490               || (relsec->sh_type != SHT_REL
7491                   && relsec->sh_type != SHT_RELA))
7492             continue;
7493
7494           arm_sec->rel_type = relsec->sh_type;
7495           if (relsec->sh_type == SHT_REL)
7496             {
7497               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7498                                      relsec->sh_size,
7499                                      & arm_sec->rela, & arm_sec->nrelas))
7500                 return FALSE;
7501             }
7502           else /* relsec->sh_type == SHT_RELA */
7503             {
7504               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7505                                       relsec->sh_size,
7506                                       & arm_sec->rela, & arm_sec->nrelas))
7507                 return FALSE;
7508             }
7509           break;
7510         }
7511
7512       arm_sec->next_rela = arm_sec->rela;
7513     }
7514
7515   /* If there is no unwind data we can do nothing.  */
7516   if (arm_sec->data == NULL)
7517     return FALSE;
7518
7519   /* If the offset is invalid then fail.  */
7520   if (word_offset > sec->sh_size - 4)
7521     return FALSE;
7522
7523   /* Get the word at the required offset.  */
7524   word = byte_get (arm_sec->data + word_offset, 4);
7525
7526   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7527   if (arm_sec->rela == NULL)
7528     {
7529       * wordp = word;
7530       return TRUE;
7531     }
7532
7533   /* Look through the relocs to find the one that applies to the provided offset.  */
7534   wrapped = FALSE;
7535   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7536     {
7537       bfd_vma prelval, offset;
7538
7539       if (rp->r_offset > word_offset && !wrapped)
7540         {
7541           rp = arm_sec->rela;
7542           wrapped = TRUE;
7543         }
7544       if (rp->r_offset > word_offset)
7545         break;
7546
7547       if (rp->r_offset & 3)
7548         {
7549           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7550                 (unsigned long) rp->r_offset);
7551           continue;
7552         }
7553
7554       if (rp->r_offset < word_offset)
7555         continue;
7556
7557       /* PR 17531: file: 027-161405-0.004  */
7558       if (aux->symtab == NULL)
7559         continue;
7560
7561       if (arm_sec->rel_type == SHT_REL)
7562         {
7563           offset = word & 0x7fffffff;
7564           if (offset & 0x40000000)
7565             offset |= ~ (bfd_vma) 0x7fffffff;
7566         }
7567       else if (arm_sec->rel_type == SHT_RELA)
7568         offset = rp->r_addend;
7569       else
7570         {
7571           error (_("Unknown section relocation type %d encountered\n"),
7572                  arm_sec->rel_type);
7573           break;
7574         }
7575
7576       /* PR 17531 file: 027-1241568-0.004.  */
7577       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7578         {
7579           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7580                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7581           break;
7582         }
7583
7584       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7585       offset += sym->st_value;
7586       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7587
7588       /* Check that we are processing the expected reloc type.  */
7589       if (elf_header.e_machine == EM_ARM)
7590         {
7591           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7592           if (relname == NULL)
7593             {
7594               warn (_("Skipping unknown ARM relocation type: %d\n"),
7595                     (int) ELF32_R_TYPE (rp->r_info));
7596               continue;
7597             }
7598
7599           if (streq (relname, "R_ARM_NONE"))
7600               continue;
7601
7602           if (! streq (relname, "R_ARM_PREL31"))
7603             {
7604               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7605               continue;
7606             }
7607         }
7608       else if (elf_header.e_machine == EM_TI_C6000)
7609         {
7610           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7611           if (relname == NULL)
7612             {
7613               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7614                     (int) ELF32_R_TYPE (rp->r_info));
7615               continue;
7616             }
7617
7618           if (streq (relname, "R_C6000_NONE"))
7619             continue;
7620
7621           if (! streq (relname, "R_C6000_PREL31"))
7622             {
7623               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7624               continue;
7625             }
7626
7627           prelval >>= 1;
7628         }
7629       else
7630         {
7631           /* This function currently only supports ARM and TI unwinders.  */
7632           warn (_("Only TI and ARM unwinders are currently supported\n"));
7633           break;
7634         }
7635
7636       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7637       addr->section = sym->st_shndx;
7638       addr->offset = offset;
7639
7640       if (sym_name)
7641         * sym_name = sym->st_name;
7642       break;
7643     }
7644
7645   *wordp = word;
7646   arm_sec->next_rela = rp;
7647
7648   return TRUE;
7649 }
7650
7651 static const char *tic6x_unwind_regnames[16] =
7652 {
7653   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7654   "A14", "A13", "A12", "A11", "A10",
7655   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7656 };
7657
7658 static void
7659 decode_tic6x_unwind_regmask (unsigned int mask)
7660 {
7661   int i;
7662
7663   for (i = 12; mask; mask >>= 1, i--)
7664     {
7665       if (mask & 1)
7666         {
7667           fputs (tic6x_unwind_regnames[i], stdout);
7668           if (mask > 1)
7669             fputs (", ", stdout);
7670         }
7671     }
7672 }
7673
7674 #define ADVANCE                                                 \
7675   if (remaining == 0 && more_words)                             \
7676     {                                                           \
7677       data_offset += 4;                                         \
7678       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7679                                      data_offset, & word, & addr, NULL))        \
7680         return;                                                 \
7681       remaining = 4;                                            \
7682       more_words--;                                             \
7683     }                                                           \
7684
7685 #define GET_OP(OP)                      \
7686   ADVANCE;                              \
7687   if (remaining)                        \
7688     {                                   \
7689       remaining--;                      \
7690       (OP) = word >> 24;                \
7691       word <<= 8;                       \
7692     }                                   \
7693   else                                  \
7694     {                                   \
7695       printf (_("[Truncated opcode]\n"));       \
7696       return;                           \
7697     }                                   \
7698   printf ("0x%02x ", OP)
7699
7700 static void
7701 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7702                             unsigned int               word,
7703                             unsigned int               remaining,
7704                             unsigned int               more_words,
7705                             bfd_vma                    data_offset,
7706                             Elf_Internal_Shdr *        data_sec,
7707                             struct arm_section *       data_arm_sec)
7708 {
7709   struct absaddr addr;
7710
7711   /* Decode the unwinding instructions.  */
7712   while (1)
7713     {
7714       unsigned int op, op2;
7715
7716       ADVANCE;
7717       if (remaining == 0)
7718         break;
7719       remaining--;
7720       op = word >> 24;
7721       word <<= 8;
7722
7723       printf ("  0x%02x ", op);
7724
7725       if ((op & 0xc0) == 0x00)
7726         {
7727           int offset = ((op & 0x3f) << 2) + 4;
7728
7729           printf ("     vsp = vsp + %d", offset);
7730         }
7731       else if ((op & 0xc0) == 0x40)
7732         {
7733           int offset = ((op & 0x3f) << 2) + 4;
7734
7735           printf ("     vsp = vsp - %d", offset);
7736         }
7737       else if ((op & 0xf0) == 0x80)
7738         {
7739           GET_OP (op2);
7740           if (op == 0x80 && op2 == 0)
7741             printf (_("Refuse to unwind"));
7742           else
7743             {
7744               unsigned int mask = ((op & 0x0f) << 8) | op2;
7745               int first = 1;
7746               int i;
7747
7748               printf ("pop {");
7749               for (i = 0; i < 12; i++)
7750                 if (mask & (1 << i))
7751                   {
7752                     if (first)
7753                       first = 0;
7754                     else
7755                       printf (", ");
7756                     printf ("r%d", 4 + i);
7757                   }
7758               printf ("}");
7759             }
7760         }
7761       else if ((op & 0xf0) == 0x90)
7762         {
7763           if (op == 0x9d || op == 0x9f)
7764             printf (_("     [Reserved]"));
7765           else
7766             printf ("     vsp = r%d", op & 0x0f);
7767         }
7768       else if ((op & 0xf0) == 0xa0)
7769         {
7770           int end = 4 + (op & 0x07);
7771           int first = 1;
7772           int i;
7773
7774           printf ("     pop {");
7775           for (i = 4; i <= end; i++)
7776             {
7777               if (first)
7778                 first = 0;
7779               else
7780                 printf (", ");
7781               printf ("r%d", i);
7782             }
7783           if (op & 0x08)
7784             {
7785               if (!first)
7786                 printf (", ");
7787               printf ("r14");
7788             }
7789           printf ("}");
7790         }
7791       else if (op == 0xb0)
7792         printf (_("     finish"));
7793       else if (op == 0xb1)
7794         {
7795           GET_OP (op2);
7796           if (op2 == 0 || (op2 & 0xf0) != 0)
7797             printf (_("[Spare]"));
7798           else
7799             {
7800               unsigned int mask = op2 & 0x0f;
7801               int first = 1;
7802               int i;
7803
7804               printf ("pop {");
7805               for (i = 0; i < 12; i++)
7806                 if (mask & (1 << i))
7807                   {
7808                     if (first)
7809                       first = 0;
7810                     else
7811                       printf (", ");
7812                     printf ("r%d", i);
7813                   }
7814               printf ("}");
7815             }
7816         }
7817       else if (op == 0xb2)
7818         {
7819           unsigned char buf[9];
7820           unsigned int i, len;
7821           unsigned long offset;
7822
7823           for (i = 0; i < sizeof (buf); i++)
7824             {
7825               GET_OP (buf[i]);
7826               if ((buf[i] & 0x80) == 0)
7827                 break;
7828             }
7829           if (i == sizeof (buf))
7830             printf (_("corrupt change to vsp"));
7831           else
7832             {
7833               offset = read_uleb128 (buf, &len, buf + i + 1);
7834               assert (len == i + 1);
7835               offset = offset * 4 + 0x204;
7836               printf ("vsp = vsp + %ld", offset);
7837             }
7838         }
7839       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7840         {
7841           unsigned int first, last;
7842
7843           GET_OP (op2);
7844           first = op2 >> 4;
7845           last = op2 & 0x0f;
7846           if (op == 0xc8)
7847             first = first + 16;
7848           printf ("pop {D%d", first);
7849           if (last)
7850             printf ("-D%d", first + last);
7851           printf ("}");
7852         }
7853       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7854         {
7855           unsigned int count = op & 0x07;
7856
7857           printf ("pop {D8");
7858           if (count)
7859             printf ("-D%d", 8 + count);
7860           printf ("}");
7861         }
7862       else if (op >= 0xc0 && op <= 0xc5)
7863         {
7864           unsigned int count = op & 0x07;
7865
7866           printf ("     pop {wR10");
7867           if (count)
7868             printf ("-wR%d", 10 + count);
7869           printf ("}");
7870         }
7871       else if (op == 0xc6)
7872         {
7873           unsigned int first, last;
7874
7875           GET_OP (op2);
7876           first = op2 >> 4;
7877           last = op2 & 0x0f;
7878           printf ("pop {wR%d", first);
7879           if (last)
7880             printf ("-wR%d", first + last);
7881           printf ("}");
7882         }
7883       else if (op == 0xc7)
7884         {
7885           GET_OP (op2);
7886           if (op2 == 0 || (op2 & 0xf0) != 0)
7887             printf (_("[Spare]"));
7888           else
7889             {
7890               unsigned int mask = op2 & 0x0f;
7891               int first = 1;
7892               int i;
7893
7894               printf ("pop {");
7895               for (i = 0; i < 4; i++)
7896                 if (mask & (1 << i))
7897                   {
7898                     if (first)
7899                       first = 0;
7900                     else
7901                       printf (", ");
7902                     printf ("wCGR%d", i);
7903                   }
7904               printf ("}");
7905             }
7906         }
7907       else
7908         printf (_("     [unsupported opcode]"));
7909       printf ("\n");
7910     }
7911 }
7912
7913 static void
7914 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
7915                               unsigned int               word,
7916                               unsigned int               remaining,
7917                               unsigned int               more_words,
7918                               bfd_vma                    data_offset,
7919                               Elf_Internal_Shdr *        data_sec,
7920                               struct arm_section *       data_arm_sec)
7921 {
7922   struct absaddr addr;
7923
7924   /* Decode the unwinding instructions.  */
7925   while (1)
7926     {
7927       unsigned int op, op2;
7928
7929       ADVANCE;
7930       if (remaining == 0)
7931         break;
7932       remaining--;
7933       op = word >> 24;
7934       word <<= 8;
7935
7936       printf ("  0x%02x ", op);
7937
7938       if ((op & 0xc0) == 0x00)
7939         {
7940           int offset = ((op & 0x3f) << 3) + 8;
7941           printf ("     sp = sp + %d", offset);
7942         }
7943       else if ((op & 0xc0) == 0x80)
7944         {
7945           GET_OP (op2);
7946           if (op == 0x80 && op2 == 0)
7947             printf (_("Refuse to unwind"));
7948           else
7949             {
7950               unsigned int mask = ((op & 0x1f) << 8) | op2;
7951               if (op & 0x20)
7952                 printf ("pop compact {");
7953               else
7954                 printf ("pop {");
7955
7956               decode_tic6x_unwind_regmask (mask);
7957               printf("}");
7958             }
7959         }
7960       else if ((op & 0xf0) == 0xc0)
7961         {
7962           unsigned int reg;
7963           unsigned int nregs;
7964           unsigned int i;
7965           const char *name;
7966           struct
7967           {
7968               unsigned int offset;
7969               unsigned int reg;
7970           } regpos[16];
7971
7972           /* Scan entire instruction first so that GET_OP output is not
7973              interleaved with disassembly.  */
7974           nregs = 0;
7975           for (i = 0; nregs < (op & 0xf); i++)
7976             {
7977               GET_OP (op2);
7978               reg = op2 >> 4;
7979               if (reg != 0xf)
7980                 {
7981                   regpos[nregs].offset = i * 2;
7982                   regpos[nregs].reg = reg;
7983                   nregs++;
7984                 }
7985
7986               reg = op2 & 0xf;
7987               if (reg != 0xf)
7988                 {
7989                   regpos[nregs].offset = i * 2 + 1;
7990                   regpos[nregs].reg = reg;
7991                   nregs++;
7992                 }
7993             }
7994
7995           printf (_("pop frame {"));
7996           reg = nregs - 1;
7997           for (i = i * 2; i > 0; i--)
7998             {
7999               if (regpos[reg].offset == i - 1)
8000                 {
8001                   name = tic6x_unwind_regnames[regpos[reg].reg];
8002                   if (reg > 0)
8003                     reg--;
8004                 }
8005               else
8006                 name = _("[pad]");
8007
8008               fputs (name, stdout);
8009               if (i > 1)
8010                 printf (", ");
8011             }
8012
8013           printf ("}");
8014         }
8015       else if (op == 0xd0)
8016         printf ("     MOV FP, SP");
8017       else if (op == 0xd1)
8018         printf ("     __c6xabi_pop_rts");
8019       else if (op == 0xd2)
8020         {
8021           unsigned char buf[9];
8022           unsigned int i, len;
8023           unsigned long offset;
8024
8025           for (i = 0; i < sizeof (buf); i++)
8026             {
8027               GET_OP (buf[i]);
8028               if ((buf[i] & 0x80) == 0)
8029                 break;
8030             }
8031           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8032           if (i == sizeof (buf))
8033             {
8034               printf ("<corrupt sp adjust>\n");
8035               warn (_("Corrupt stack pointer adjustment detected\n"));
8036               return;
8037             }
8038
8039           offset = read_uleb128 (buf, &len, buf + i + 1);
8040           assert (len == i + 1);
8041           offset = offset * 8 + 0x408;
8042           printf (_("sp = sp + %ld"), offset);
8043         }
8044       else if ((op & 0xf0) == 0xe0)
8045         {
8046           if ((op & 0x0f) == 7)
8047             printf ("     RETURN");
8048           else
8049             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8050         }
8051       else
8052         {
8053           printf (_("     [unsupported opcode]"));
8054         }
8055       putchar ('\n');
8056     }
8057 }
8058
8059 static bfd_vma
8060 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8061 {
8062   bfd_vma offset;
8063
8064   offset = word & 0x7fffffff;
8065   if (offset & 0x40000000)
8066     offset |= ~ (bfd_vma) 0x7fffffff;
8067
8068   if (elf_header.e_machine == EM_TI_C6000)
8069     offset <<= 1;
8070
8071   return offset + where;
8072 }
8073
8074 static void
8075 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8076                    unsigned int               word,
8077                    unsigned int               remaining,
8078                    bfd_vma                    data_offset,
8079                    Elf_Internal_Shdr *        data_sec,
8080                    struct arm_section *       data_arm_sec)
8081 {
8082   int per_index;
8083   unsigned int more_words = 0;
8084   struct absaddr addr;
8085   bfd_vma sym_name = (bfd_vma) -1;
8086
8087   if (remaining == 0)
8088     {
8089       /* Fetch the first word.
8090          Note - when decoding an object file the address extracted
8091          here will always be 0.  So we also pass in the sym_name
8092          parameter so that we can find the symbol associated with
8093          the personality routine.  */
8094       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8095                                      & word, & addr, & sym_name))
8096         return;
8097
8098       remaining = 4;
8099     }
8100
8101   if ((word & 0x80000000) == 0)
8102     {
8103       /* Expand prel31 for personality routine.  */
8104       bfd_vma fn;
8105       const char *procname;
8106
8107       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8108       printf (_("  Personality routine: "));
8109       if (fn == 0
8110           && addr.section == SHN_UNDEF && addr.offset == 0
8111           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8112         {
8113           procname = aux->strtab + sym_name;
8114           print_vma (fn, PREFIX_HEX);
8115           if (procname)
8116             {
8117               fputs (" <", stdout);
8118               fputs (procname, stdout);
8119               fputc ('>', stdout);
8120             }
8121         }
8122       else
8123         procname = arm_print_vma_and_name (aux, fn, addr);
8124       fputc ('\n', stdout);
8125
8126       /* The GCC personality routines use the standard compact
8127          encoding, starting with one byte giving the number of
8128          words.  */
8129       if (procname != NULL
8130           && (const_strneq (procname, "__gcc_personality_v0")
8131               || const_strneq (procname, "__gxx_personality_v0")
8132               || const_strneq (procname, "__gcj_personality_v0")
8133               || const_strneq (procname, "__gnu_objc_personality_v0")))
8134         {
8135           remaining = 0;
8136           more_words = 1;
8137           ADVANCE;
8138           if (!remaining)
8139             {
8140               printf (_("  [Truncated data]\n"));
8141               return;
8142             }
8143           more_words = word >> 24;
8144           word <<= 8;
8145           remaining--;
8146           per_index = -1;
8147         }
8148       else
8149         return;
8150     }
8151   else
8152     {
8153       /* ARM EHABI Section 6.3:
8154
8155          An exception-handling table entry for the compact model looks like:
8156
8157            31 30-28 27-24 23-0
8158            -- ----- ----- ----
8159             1   0   index Data for personalityRoutine[index]    */
8160
8161       if (elf_header.e_machine == EM_ARM
8162           && (word & 0x70000000))
8163         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8164
8165       per_index = (word >> 24) & 0x7f;
8166       printf (_("  Compact model index: %d\n"), per_index);
8167       if (per_index == 0)
8168         {
8169           more_words = 0;
8170           word <<= 8;
8171           remaining--;
8172         }
8173       else if (per_index < 3)
8174         {
8175           more_words = (word >> 16) & 0xff;
8176           word <<= 16;
8177           remaining -= 2;
8178         }
8179     }
8180
8181   switch (elf_header.e_machine)
8182     {
8183     case EM_ARM:
8184       if (per_index < 3)
8185         {
8186           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8187                                       data_offset, data_sec, data_arm_sec);
8188         }
8189       else
8190         {
8191           warn (_("Unknown ARM compact model index encountered\n"));
8192           printf (_("  [reserved]\n"));
8193         }
8194       break;
8195
8196     case EM_TI_C6000:
8197       if (per_index < 3)
8198         {
8199           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8200                                         data_offset, data_sec, data_arm_sec);
8201         }
8202       else if (per_index < 5)
8203         {
8204           if (((word >> 17) & 0x7f) == 0x7f)
8205             printf (_("  Restore stack from frame pointer\n"));
8206           else
8207             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8208           printf (_("  Registers restored: "));
8209           if (per_index == 4)
8210             printf (" (compact) ");
8211           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8212           putchar ('\n');
8213           printf (_("  Return register: %s\n"),
8214                   tic6x_unwind_regnames[word & 0xf]);
8215         }
8216       else
8217         printf (_("  [reserved (%d)]\n"), per_index);
8218       break;
8219
8220     default:
8221       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8222              elf_header.e_machine);
8223     }
8224
8225   /* Decode the descriptors.  Not implemented.  */
8226 }
8227
8228 static void
8229 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8230 {
8231   struct arm_section exidx_arm_sec, extab_arm_sec;
8232   unsigned int i, exidx_len;
8233   unsigned long j, nfuns;
8234
8235   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8236   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8237   exidx_len = exidx_sec->sh_size / 8;
8238
8239   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8240   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8241     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8242       aux->funtab[nfuns++] = aux->symtab[j];
8243   aux->nfuns = nfuns;
8244   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8245
8246   for (i = 0; i < exidx_len; i++)
8247     {
8248       unsigned int exidx_fn, exidx_entry;
8249       struct absaddr fn_addr, entry_addr;
8250       bfd_vma fn;
8251
8252       fputc ('\n', stdout);
8253
8254       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8255                                      8 * i, & exidx_fn, & fn_addr, NULL)
8256           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8257                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8258         {
8259           free (aux->funtab);
8260           arm_free_section (& exidx_arm_sec);
8261           arm_free_section (& extab_arm_sec);
8262           return;
8263         }
8264
8265       /* ARM EHABI, Section 5:
8266          An index table entry consists of 2 words.
8267          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8268       if (exidx_fn & 0x80000000)
8269         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8270
8271       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8272
8273       arm_print_vma_and_name (aux, fn, fn_addr);
8274       fputs (": ", stdout);
8275
8276       if (exidx_entry == 1)
8277         {
8278           print_vma (exidx_entry, PREFIX_HEX);
8279           fputs (" [cantunwind]\n", stdout);
8280         }
8281       else if (exidx_entry & 0x80000000)
8282         {
8283           print_vma (exidx_entry, PREFIX_HEX);
8284           fputc ('\n', stdout);
8285           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8286         }
8287       else
8288         {
8289           bfd_vma table, table_offset = 0;
8290           Elf_Internal_Shdr *table_sec;
8291
8292           fputs ("@", stdout);
8293           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8294           print_vma (table, PREFIX_HEX);
8295           printf ("\n");
8296
8297           /* Locate the matching .ARM.extab.  */
8298           if (entry_addr.section != SHN_UNDEF
8299               && entry_addr.section < elf_header.e_shnum)
8300             {
8301               table_sec = section_headers + entry_addr.section;
8302               table_offset = entry_addr.offset;
8303             }
8304           else
8305             {
8306               table_sec = find_section_by_address (table);
8307               if (table_sec != NULL)
8308                 table_offset = table - table_sec->sh_addr;
8309             }
8310           if (table_sec == NULL)
8311             {
8312               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8313                     (unsigned long) table);
8314               continue;
8315             }
8316           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8317                              &extab_arm_sec);
8318         }
8319     }
8320
8321   printf ("\n");
8322
8323   free (aux->funtab);
8324   arm_free_section (&exidx_arm_sec);
8325   arm_free_section (&extab_arm_sec);
8326 }
8327
8328 /* Used for both ARM and C6X unwinding tables.  */
8329
8330 static void
8331 arm_process_unwind (FILE *file)
8332 {
8333   struct arm_unw_aux_info aux;
8334   Elf_Internal_Shdr *unwsec = NULL;
8335   Elf_Internal_Shdr *strsec;
8336   Elf_Internal_Shdr *sec;
8337   unsigned long i;
8338   unsigned int sec_type;
8339
8340   switch (elf_header.e_machine)
8341     {
8342     case EM_ARM:
8343       sec_type = SHT_ARM_EXIDX;
8344       break;
8345
8346     case EM_TI_C6000:
8347       sec_type = SHT_C6000_UNWIND;
8348       break;
8349
8350     default:
8351       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8352              elf_header.e_machine);
8353       return;
8354     }
8355
8356   if (string_table == NULL)
8357     return;
8358
8359   memset (& aux, 0, sizeof (aux));
8360   aux.file = file;
8361
8362   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8363     {
8364       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8365         {
8366           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8367
8368           strsec = section_headers + sec->sh_link;
8369
8370           /* PR binutils/17531 file: 011-12666-0.004.  */
8371           if (aux.strtab != NULL)
8372             {
8373               error (_("Multiple string tables found in file.\n"));
8374               free (aux.strtab);
8375             }
8376           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8377                                  1, strsec->sh_size, _("string table"));
8378           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8379         }
8380       else if (sec->sh_type == sec_type)
8381         unwsec = sec;
8382     }
8383
8384   if (unwsec == NULL)
8385     printf (_("\nThere are no unwind sections in this file.\n"));
8386   else
8387     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8388       {
8389         if (sec->sh_type == sec_type)
8390           {
8391             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8392                     printable_section_name (sec),
8393                     (unsigned long) sec->sh_offset,
8394                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8395
8396             dump_arm_unwind (&aux, sec);
8397           }
8398       }
8399
8400   if (aux.symtab)
8401     free (aux.symtab);
8402   if (aux.strtab)
8403     free ((char *) aux.strtab);
8404 }
8405
8406 static void
8407 process_unwind (FILE * file)
8408 {
8409   struct unwind_handler
8410   {
8411     int machtype;
8412     void (* handler)(FILE *);
8413   } handlers[] =
8414   {
8415     { EM_ARM, arm_process_unwind },
8416     { EM_IA_64, ia64_process_unwind },
8417     { EM_PARISC, hppa_process_unwind },
8418     { EM_TI_C6000, arm_process_unwind },
8419     { 0, 0 }
8420   };
8421   int i;
8422
8423   if (!do_unwind)
8424     return;
8425
8426   for (i = 0; handlers[i].handler != NULL; i++)
8427     if (elf_header.e_machine == handlers[i].machtype)
8428       {
8429         handlers[i].handler (file);
8430         return;
8431       }
8432
8433   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8434           get_machine_name (elf_header.e_machine));
8435 }
8436
8437 static void
8438 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8439 {
8440   switch (entry->d_tag)
8441     {
8442     case DT_MIPS_FLAGS:
8443       if (entry->d_un.d_val == 0)
8444         printf (_("NONE"));
8445       else
8446         {
8447           static const char * opts[] =
8448           {
8449             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8450             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8451             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8452             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8453             "RLD_ORDER_SAFE"
8454           };
8455           unsigned int cnt;
8456           int first = 1;
8457
8458           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8459             if (entry->d_un.d_val & (1 << cnt))
8460               {
8461                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8462                 first = 0;
8463               }
8464         }
8465       break;
8466
8467     case DT_MIPS_IVERSION:
8468       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8469         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8470       else
8471         {
8472           char buf[40];
8473           sprintf_vma (buf, entry->d_un.d_ptr);
8474           /* Note: coded this way so that there is a single string for translation.  */
8475           printf (_("<corrupt: %s>"), buf);
8476         }
8477       break;
8478
8479     case DT_MIPS_TIME_STAMP:
8480       {
8481         char timebuf[20];
8482         struct tm * tmp;
8483         time_t atime = entry->d_un.d_val;
8484
8485         tmp = gmtime (&atime);
8486         /* PR 17531: file: 6accc532.  */
8487         if (tmp == NULL)
8488           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8489         else
8490           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8491                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8492                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8493         printf (_("Time Stamp: %s"), timebuf);
8494       }
8495       break;
8496
8497     case DT_MIPS_RLD_VERSION:
8498     case DT_MIPS_LOCAL_GOTNO:
8499     case DT_MIPS_CONFLICTNO:
8500     case DT_MIPS_LIBLISTNO:
8501     case DT_MIPS_SYMTABNO:
8502     case DT_MIPS_UNREFEXTNO:
8503     case DT_MIPS_HIPAGENO:
8504     case DT_MIPS_DELTA_CLASS_NO:
8505     case DT_MIPS_DELTA_INSTANCE_NO:
8506     case DT_MIPS_DELTA_RELOC_NO:
8507     case DT_MIPS_DELTA_SYM_NO:
8508     case DT_MIPS_DELTA_CLASSSYM_NO:
8509     case DT_MIPS_COMPACT_SIZE:
8510       print_vma (entry->d_un.d_ptr, DEC);
8511       break;
8512
8513     default:
8514       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8515     }
8516     putchar ('\n');
8517 }
8518
8519 static void
8520 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8521 {
8522   switch (entry->d_tag)
8523     {
8524     case DT_HP_DLD_FLAGS:
8525       {
8526         static struct
8527         {
8528           long int bit;
8529           const char * str;
8530         }
8531         flags[] =
8532         {
8533           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8534           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8535           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8536           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8537           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8538           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8539           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8540           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8541           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8542           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8543           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8544           { DT_HP_GST, "HP_GST" },
8545           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8546           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8547           { DT_HP_NODELETE, "HP_NODELETE" },
8548           { DT_HP_GROUP, "HP_GROUP" },
8549           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8550         };
8551         int first = 1;
8552         size_t cnt;
8553         bfd_vma val = entry->d_un.d_val;
8554
8555         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8556           if (val & flags[cnt].bit)
8557             {
8558               if (! first)
8559                 putchar (' ');
8560               fputs (flags[cnt].str, stdout);
8561               first = 0;
8562               val ^= flags[cnt].bit;
8563             }
8564
8565         if (val != 0 || first)
8566           {
8567             if (! first)
8568               putchar (' ');
8569             print_vma (val, HEX);
8570           }
8571       }
8572       break;
8573
8574     default:
8575       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8576       break;
8577     }
8578   putchar ('\n');
8579 }
8580
8581 #ifdef BFD64
8582
8583 /* VMS vs Unix time offset and factor.  */
8584
8585 #define VMS_EPOCH_OFFSET 35067168000000000LL
8586 #define VMS_GRANULARITY_FACTOR 10000000
8587
8588 /* Display a VMS time in a human readable format.  */
8589
8590 static void
8591 print_vms_time (bfd_int64_t vmstime)
8592 {
8593   struct tm *tm;
8594   time_t unxtime;
8595
8596   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8597   tm = gmtime (&unxtime);
8598   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8599           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8600           tm->tm_hour, tm->tm_min, tm->tm_sec);
8601 }
8602 #endif /* BFD64 */
8603
8604 static void
8605 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8606 {
8607   switch (entry->d_tag)
8608     {
8609     case DT_IA_64_PLT_RESERVE:
8610       /* First 3 slots reserved.  */
8611       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8612       printf (" -- ");
8613       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8614       break;
8615
8616     case DT_IA_64_VMS_LINKTIME:
8617 #ifdef BFD64
8618       print_vms_time (entry->d_un.d_val);
8619 #endif
8620       break;
8621
8622     case DT_IA_64_VMS_LNKFLAGS:
8623       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8624       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8625         printf (" CALL_DEBUG");
8626       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8627         printf (" NOP0BUFS");
8628       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8629         printf (" P0IMAGE");
8630       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8631         printf (" MKTHREADS");
8632       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8633         printf (" UPCALLS");
8634       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8635         printf (" IMGSTA");
8636       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8637         printf (" INITIALIZE");
8638       if (entry->d_un.d_val & VMS_LF_MAIN)
8639         printf (" MAIN");
8640       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8641         printf (" EXE_INIT");
8642       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8643         printf (" TBK_IN_IMG");
8644       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8645         printf (" DBG_IN_IMG");
8646       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8647         printf (" TBK_IN_DSF");
8648       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8649         printf (" DBG_IN_DSF");
8650       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8651         printf (" SIGNATURES");
8652       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8653         printf (" REL_SEG_OFF");
8654       break;
8655
8656     default:
8657       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8658       break;
8659     }
8660   putchar ('\n');
8661 }
8662
8663 static int
8664 get_32bit_dynamic_section (FILE * file)
8665 {
8666   Elf32_External_Dyn * edyn;
8667   Elf32_External_Dyn * ext;
8668   Elf_Internal_Dyn * entry;
8669
8670   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8671                                           dynamic_size, _("dynamic section"));
8672   if (!edyn)
8673     return 0;
8674
8675   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8676      might not have the luxury of section headers.  Look for the DT_NULL
8677      terminator to determine the number of entries.  */
8678   for (ext = edyn, dynamic_nent = 0;
8679        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8680        ext++)
8681     {
8682       dynamic_nent++;
8683       if (BYTE_GET (ext->d_tag) == DT_NULL)
8684         break;
8685     }
8686
8687   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8688                                                   sizeof (* entry));
8689   if (dynamic_section == NULL)
8690     {
8691       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8692              (unsigned long) dynamic_nent);
8693       free (edyn);
8694       return 0;
8695     }
8696
8697   for (ext = edyn, entry = dynamic_section;
8698        entry < dynamic_section + dynamic_nent;
8699        ext++, entry++)
8700     {
8701       entry->d_tag      = BYTE_GET (ext->d_tag);
8702       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8703     }
8704
8705   free (edyn);
8706
8707   return 1;
8708 }
8709
8710 static int
8711 get_64bit_dynamic_section (FILE * file)
8712 {
8713   Elf64_External_Dyn * edyn;
8714   Elf64_External_Dyn * ext;
8715   Elf_Internal_Dyn * entry;
8716
8717   /* Read in the data.  */
8718   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8719                                           dynamic_size, _("dynamic section"));
8720   if (!edyn)
8721     return 0;
8722
8723   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8724      might not have the luxury of section headers.  Look for the DT_NULL
8725      terminator to determine the number of entries.  */
8726   for (ext = edyn, dynamic_nent = 0;
8727        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8728        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8729        ext++)
8730     {
8731       dynamic_nent++;
8732       if (BYTE_GET (ext->d_tag) == DT_NULL)
8733         break;
8734     }
8735
8736   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8737                                                   sizeof (* entry));
8738   if (dynamic_section == NULL)
8739     {
8740       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8741              (unsigned long) dynamic_nent);
8742       free (edyn);
8743       return 0;
8744     }
8745
8746   /* Convert from external to internal formats.  */
8747   for (ext = edyn, entry = dynamic_section;
8748        entry < dynamic_section + dynamic_nent;
8749        ext++, entry++)
8750     {
8751       entry->d_tag      = BYTE_GET (ext->d_tag);
8752       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8753     }
8754
8755   free (edyn);
8756
8757   return 1;
8758 }
8759
8760 static void
8761 print_dynamic_flags (bfd_vma flags)
8762 {
8763   int first = 1;
8764
8765   while (flags)
8766     {
8767       bfd_vma flag;
8768
8769       flag = flags & - flags;
8770       flags &= ~ flag;
8771
8772       if (first)
8773         first = 0;
8774       else
8775         putc (' ', stdout);
8776
8777       switch (flag)
8778         {
8779         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8780         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8781         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8782         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8783         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8784         default:                fputs (_("unknown"), stdout); break;
8785         }
8786     }
8787   puts ("");
8788 }
8789
8790 /* Parse and display the contents of the dynamic section.  */
8791
8792 static int
8793 process_dynamic_section (FILE * file)
8794 {
8795   Elf_Internal_Dyn * entry;
8796
8797   if (dynamic_size == 0)
8798     {
8799       if (do_dynamic)
8800         printf (_("\nThere is no dynamic section in this file.\n"));
8801
8802       return 1;
8803     }
8804
8805   if (is_32bit_elf)
8806     {
8807       if (! get_32bit_dynamic_section (file))
8808         return 0;
8809     }
8810   else if (! get_64bit_dynamic_section (file))
8811     return 0;
8812
8813   /* Find the appropriate symbol table.  */
8814   if (dynamic_symbols == NULL)
8815     {
8816       for (entry = dynamic_section;
8817            entry < dynamic_section + dynamic_nent;
8818            ++entry)
8819         {
8820           Elf_Internal_Shdr section;
8821
8822           if (entry->d_tag != DT_SYMTAB)
8823             continue;
8824
8825           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8826
8827           /* Since we do not know how big the symbol table is,
8828              we default to reading in the entire file (!) and
8829              processing that.  This is overkill, I know, but it
8830              should work.  */
8831           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8832
8833           if (archive_file_offset != 0)
8834             section.sh_size = archive_file_size - section.sh_offset;
8835           else
8836             {
8837               if (fseek (file, 0, SEEK_END))
8838                 error (_("Unable to seek to end of file!\n"));
8839
8840               section.sh_size = ftell (file) - section.sh_offset;
8841             }
8842
8843           if (is_32bit_elf)
8844             section.sh_entsize = sizeof (Elf32_External_Sym);
8845           else
8846             section.sh_entsize = sizeof (Elf64_External_Sym);
8847           section.sh_name = string_table_length;
8848
8849           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8850           if (num_dynamic_syms < 1)
8851             {
8852               error (_("Unable to determine the number of symbols to load\n"));
8853               continue;
8854             }
8855         }
8856     }
8857
8858   /* Similarly find a string table.  */
8859   if (dynamic_strings == NULL)
8860     {
8861       for (entry = dynamic_section;
8862            entry < dynamic_section + dynamic_nent;
8863            ++entry)
8864         {
8865           unsigned long offset;
8866           long str_tab_len;
8867
8868           if (entry->d_tag != DT_STRTAB)
8869             continue;
8870
8871           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8872
8873           /* Since we do not know how big the string table is,
8874              we default to reading in the entire file (!) and
8875              processing that.  This is overkill, I know, but it
8876              should work.  */
8877
8878           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8879
8880           if (archive_file_offset != 0)
8881             str_tab_len = archive_file_size - offset;
8882           else
8883             {
8884               if (fseek (file, 0, SEEK_END))
8885                 error (_("Unable to seek to end of file\n"));
8886               str_tab_len = ftell (file) - offset;
8887             }
8888
8889           if (str_tab_len < 1)
8890             {
8891               error
8892                 (_("Unable to determine the length of the dynamic string table\n"));
8893               continue;
8894             }
8895
8896           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8897                                                str_tab_len,
8898                                                _("dynamic string table"));
8899           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8900           break;
8901         }
8902     }
8903
8904   /* And find the syminfo section if available.  */
8905   if (dynamic_syminfo == NULL)
8906     {
8907       unsigned long syminsz = 0;
8908
8909       for (entry = dynamic_section;
8910            entry < dynamic_section + dynamic_nent;
8911            ++entry)
8912         {
8913           if (entry->d_tag == DT_SYMINENT)
8914             {
8915               /* Note: these braces are necessary to avoid a syntax
8916                  error from the SunOS4 C compiler.  */
8917               /* PR binutils/17531: A corrupt file can trigger this test.
8918                  So do not use an assert, instead generate an error message.  */
8919               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8920                 error (_("Bad value (%d) for SYMINENT entry\n"),
8921                        (int) entry->d_un.d_val);
8922             }
8923           else if (entry->d_tag == DT_SYMINSZ)
8924             syminsz = entry->d_un.d_val;
8925           else if (entry->d_tag == DT_SYMINFO)
8926             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8927                                                       syminsz);
8928         }
8929
8930       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8931         {
8932           Elf_External_Syminfo * extsyminfo;
8933           Elf_External_Syminfo * extsym;
8934           Elf_Internal_Syminfo * syminfo;
8935
8936           /* There is a syminfo section.  Read the data.  */
8937           extsyminfo = (Elf_External_Syminfo *)
8938               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8939                         _("symbol information"));
8940           if (!extsyminfo)
8941             return 0;
8942
8943           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8944           if (dynamic_syminfo == NULL)
8945             {
8946               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8947                      (unsigned long) syminsz);
8948               return 0;
8949             }
8950
8951           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8952           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8953                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8954                ++syminfo, ++extsym)
8955             {
8956               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8957               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8958             }
8959
8960           free (extsyminfo);
8961         }
8962     }
8963
8964   if (do_dynamic && dynamic_addr)
8965     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8966             dynamic_addr, (unsigned long) dynamic_nent);
8967   if (do_dynamic)
8968     printf (_("  Tag        Type                         Name/Value\n"));
8969
8970   for (entry = dynamic_section;
8971        entry < dynamic_section + dynamic_nent;
8972        entry++)
8973     {
8974       if (do_dynamic)
8975         {
8976           const char * dtype;
8977
8978           putchar (' ');
8979           print_vma (entry->d_tag, FULL_HEX);
8980           dtype = get_dynamic_type (entry->d_tag);
8981           printf (" (%s)%*s", dtype,
8982                   ((is_32bit_elf ? 27 : 19)
8983                    - (int) strlen (dtype)),
8984                   " ");
8985         }
8986
8987       switch (entry->d_tag)
8988         {
8989         case DT_FLAGS:
8990           if (do_dynamic)
8991             print_dynamic_flags (entry->d_un.d_val);
8992           break;
8993
8994         case DT_AUXILIARY:
8995         case DT_FILTER:
8996         case DT_CONFIG:
8997         case DT_DEPAUDIT:
8998         case DT_AUDIT:
8999           if (do_dynamic)
9000             {
9001               switch (entry->d_tag)
9002                 {
9003                 case DT_AUXILIARY:
9004                   printf (_("Auxiliary library"));
9005                   break;
9006
9007                 case DT_FILTER:
9008                   printf (_("Filter library"));
9009                   break;
9010
9011                 case DT_CONFIG:
9012                   printf (_("Configuration file"));
9013                   break;
9014
9015                 case DT_DEPAUDIT:
9016                   printf (_("Dependency audit library"));
9017                   break;
9018
9019                 case DT_AUDIT:
9020                   printf (_("Audit library"));
9021                   break;
9022                 }
9023
9024               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9025                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9026               else
9027                 {
9028                   printf (": ");
9029                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9030                   putchar ('\n');
9031                 }
9032             }
9033           break;
9034
9035         case DT_FEATURE:
9036           if (do_dynamic)
9037             {
9038               printf (_("Flags:"));
9039
9040               if (entry->d_un.d_val == 0)
9041                 printf (_(" None\n"));
9042               else
9043                 {
9044                   unsigned long int val = entry->d_un.d_val;
9045
9046                   if (val & DTF_1_PARINIT)
9047                     {
9048                       printf (" PARINIT");
9049                       val ^= DTF_1_PARINIT;
9050                     }
9051                   if (val & DTF_1_CONFEXP)
9052                     {
9053                       printf (" CONFEXP");
9054                       val ^= DTF_1_CONFEXP;
9055                     }
9056                   if (val != 0)
9057                     printf (" %lx", val);
9058                   puts ("");
9059                 }
9060             }
9061           break;
9062
9063         case DT_POSFLAG_1:
9064           if (do_dynamic)
9065             {
9066               printf (_("Flags:"));
9067
9068               if (entry->d_un.d_val == 0)
9069                 printf (_(" None\n"));
9070               else
9071                 {
9072                   unsigned long int val = entry->d_un.d_val;
9073
9074                   if (val & DF_P1_LAZYLOAD)
9075                     {
9076                       printf (" LAZYLOAD");
9077                       val ^= DF_P1_LAZYLOAD;
9078                     }
9079                   if (val & DF_P1_GROUPPERM)
9080                     {
9081                       printf (" GROUPPERM");
9082                       val ^= DF_P1_GROUPPERM;
9083                     }
9084                   if (val != 0)
9085                     printf (" %lx", val);
9086                   puts ("");
9087                 }
9088             }
9089           break;
9090
9091         case DT_FLAGS_1:
9092           if (do_dynamic)
9093             {
9094               printf (_("Flags:"));
9095               if (entry->d_un.d_val == 0)
9096                 printf (_(" None\n"));
9097               else
9098                 {
9099                   unsigned long int val = entry->d_un.d_val;
9100
9101                   if (val & DF_1_NOW)
9102                     {
9103                       printf (" NOW");
9104                       val ^= DF_1_NOW;
9105                     }
9106                   if (val & DF_1_GLOBAL)
9107                     {
9108                       printf (" GLOBAL");
9109                       val ^= DF_1_GLOBAL;
9110                     }
9111                   if (val & DF_1_GROUP)
9112                     {
9113                       printf (" GROUP");
9114                       val ^= DF_1_GROUP;
9115                     }
9116                   if (val & DF_1_NODELETE)
9117                     {
9118                       printf (" NODELETE");
9119                       val ^= DF_1_NODELETE;
9120                     }
9121                   if (val & DF_1_LOADFLTR)
9122                     {
9123                       printf (" LOADFLTR");
9124                       val ^= DF_1_LOADFLTR;
9125                     }
9126                   if (val & DF_1_INITFIRST)
9127                     {
9128                       printf (" INITFIRST");
9129                       val ^= DF_1_INITFIRST;
9130                     }
9131                   if (val & DF_1_NOOPEN)
9132                     {
9133                       printf (" NOOPEN");
9134                       val ^= DF_1_NOOPEN;
9135                     }
9136                   if (val & DF_1_ORIGIN)
9137                     {
9138                       printf (" ORIGIN");
9139                       val ^= DF_1_ORIGIN;
9140                     }
9141                   if (val & DF_1_DIRECT)
9142                     {
9143                       printf (" DIRECT");
9144                       val ^= DF_1_DIRECT;
9145                     }
9146                   if (val & DF_1_TRANS)
9147                     {
9148                       printf (" TRANS");
9149                       val ^= DF_1_TRANS;
9150                     }
9151                   if (val & DF_1_INTERPOSE)
9152                     {
9153                       printf (" INTERPOSE");
9154                       val ^= DF_1_INTERPOSE;
9155                     }
9156                   if (val & DF_1_NODEFLIB)
9157                     {
9158                       printf (" NODEFLIB");
9159                       val ^= DF_1_NODEFLIB;
9160                     }
9161                   if (val & DF_1_NODUMP)
9162                     {
9163                       printf (" NODUMP");
9164                       val ^= DF_1_NODUMP;
9165                     }
9166                   if (val & DF_1_CONFALT)
9167                     {
9168                       printf (" CONFALT");
9169                       val ^= DF_1_CONFALT;
9170                     }
9171                   if (val & DF_1_ENDFILTEE)
9172                     {
9173                       printf (" ENDFILTEE");
9174                       val ^= DF_1_ENDFILTEE;
9175                     }
9176                   if (val & DF_1_DISPRELDNE)
9177                     {
9178                       printf (" DISPRELDNE");
9179                       val ^= DF_1_DISPRELDNE;
9180                     }
9181                   if (val & DF_1_DISPRELPND)
9182                     {
9183                       printf (" DISPRELPND");
9184                       val ^= DF_1_DISPRELPND;
9185                     }
9186                   if (val & DF_1_NODIRECT)
9187                     {
9188                       printf (" NODIRECT");
9189                       val ^= DF_1_NODIRECT;
9190                     }
9191                   if (val & DF_1_IGNMULDEF)
9192                     {
9193                       printf (" IGNMULDEF");
9194                       val ^= DF_1_IGNMULDEF;
9195                     }
9196                   if (val & DF_1_NOKSYMS)
9197                     {
9198                       printf (" NOKSYMS");
9199                       val ^= DF_1_NOKSYMS;
9200                     }
9201                   if (val & DF_1_NOHDR)
9202                     {
9203                       printf (" NOHDR");
9204                       val ^= DF_1_NOHDR;
9205                     }
9206                   if (val & DF_1_EDITED)
9207                     {
9208                       printf (" EDITED");
9209                       val ^= DF_1_EDITED;
9210                     }
9211                   if (val & DF_1_NORELOC)
9212                     {
9213                       printf (" NORELOC");
9214                       val ^= DF_1_NORELOC;
9215                     }
9216                   if (val & DF_1_SYMINTPOSE)
9217                     {
9218                       printf (" SYMINTPOSE");
9219                       val ^= DF_1_SYMINTPOSE;
9220                     }
9221                   if (val & DF_1_GLOBAUDIT)
9222                     {
9223                       printf (" GLOBAUDIT");
9224                       val ^= DF_1_GLOBAUDIT;
9225                     }
9226                   if (val & DF_1_SINGLETON)
9227                     {
9228                       printf (" SINGLETON");
9229                       val ^= DF_1_SINGLETON;
9230                     }
9231                   if (val != 0)
9232                     printf (" %lx", val);
9233                   puts ("");
9234                 }
9235             }
9236           break;
9237
9238         case DT_PLTREL:
9239           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9240           if (do_dynamic)
9241             puts (get_dynamic_type (entry->d_un.d_val));
9242           break;
9243
9244         case DT_NULL    :
9245         case DT_NEEDED  :
9246         case DT_PLTGOT  :
9247         case DT_HASH    :
9248         case DT_STRTAB  :
9249         case DT_SYMTAB  :
9250         case DT_RELA    :
9251         case DT_INIT    :
9252         case DT_FINI    :
9253         case DT_SONAME  :
9254         case DT_RPATH   :
9255         case DT_SYMBOLIC:
9256         case DT_REL     :
9257         case DT_DEBUG   :
9258         case DT_TEXTREL :
9259         case DT_JMPREL  :
9260         case DT_RUNPATH :
9261           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9262
9263           if (do_dynamic)
9264             {
9265               char * name;
9266
9267               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9268                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9269               else
9270                 name = NULL;
9271
9272               if (name)
9273                 {
9274                   switch (entry->d_tag)
9275                     {
9276                     case DT_NEEDED:
9277                       printf (_("Shared library: [%s]"), name);
9278
9279                       if (streq (name, program_interpreter))
9280                         printf (_(" program interpreter"));
9281                       break;
9282
9283                     case DT_SONAME:
9284                       printf (_("Library soname: [%s]"), name);
9285                       break;
9286
9287                     case DT_RPATH:
9288                       printf (_("Library rpath: [%s]"), name);
9289                       break;
9290
9291                     case DT_RUNPATH:
9292                       printf (_("Library runpath: [%s]"), name);
9293                       break;
9294
9295                     default:
9296                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9297                       break;
9298                     }
9299                 }
9300               else
9301                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9302
9303               putchar ('\n');
9304             }
9305           break;
9306
9307         case DT_PLTRELSZ:
9308         case DT_RELASZ  :
9309         case DT_STRSZ   :
9310         case DT_RELSZ   :
9311         case DT_RELAENT :
9312         case DT_SYMENT  :
9313         case DT_RELENT  :
9314           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9315         case DT_PLTPADSZ:
9316         case DT_MOVEENT :
9317         case DT_MOVESZ  :
9318         case DT_INIT_ARRAYSZ:
9319         case DT_FINI_ARRAYSZ:
9320         case DT_GNU_CONFLICTSZ:
9321         case DT_GNU_LIBLISTSZ:
9322           if (do_dynamic)
9323             {
9324               print_vma (entry->d_un.d_val, UNSIGNED);
9325               printf (_(" (bytes)\n"));
9326             }
9327           break;
9328
9329         case DT_VERDEFNUM:
9330         case DT_VERNEEDNUM:
9331         case DT_RELACOUNT:
9332         case DT_RELCOUNT:
9333           if (do_dynamic)
9334             {
9335               print_vma (entry->d_un.d_val, UNSIGNED);
9336               putchar ('\n');
9337             }
9338           break;
9339
9340         case DT_SYMINSZ:
9341         case DT_SYMINENT:
9342         case DT_SYMINFO:
9343         case DT_USED:
9344         case DT_INIT_ARRAY:
9345         case DT_FINI_ARRAY:
9346           if (do_dynamic)
9347             {
9348               if (entry->d_tag == DT_USED
9349                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9350                 {
9351                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9352
9353                   if (*name)
9354                     {
9355                       printf (_("Not needed object: [%s]\n"), name);
9356                       break;
9357                     }
9358                 }
9359
9360               print_vma (entry->d_un.d_val, PREFIX_HEX);
9361               putchar ('\n');
9362             }
9363           break;
9364
9365         case DT_BIND_NOW:
9366           /* The value of this entry is ignored.  */
9367           if (do_dynamic)
9368             putchar ('\n');
9369           break;
9370
9371         case DT_GNU_PRELINKED:
9372           if (do_dynamic)
9373             {
9374               struct tm * tmp;
9375               time_t atime = entry->d_un.d_val;
9376
9377               tmp = gmtime (&atime);
9378               /* PR 17533 file: 041-1244816-0.004.  */
9379               if (tmp == NULL)
9380                 printf (_("<corrupt time val: %lx"),
9381                         (unsigned long) atime);
9382               else
9383                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9384                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9385                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9386
9387             }
9388           break;
9389
9390         case DT_GNU_HASH:
9391           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9392           if (do_dynamic)
9393             {
9394               print_vma (entry->d_un.d_val, PREFIX_HEX);
9395               putchar ('\n');
9396             }
9397           break;
9398
9399         default:
9400           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9401             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9402               entry->d_un.d_val;
9403
9404           if (do_dynamic)
9405             {
9406               switch (elf_header.e_machine)
9407                 {
9408                 case EM_MIPS:
9409                 case EM_MIPS_RS3_LE:
9410                   dynamic_section_mips_val (entry);
9411                   break;
9412                 case EM_PARISC:
9413                   dynamic_section_parisc_val (entry);
9414                   break;
9415                 case EM_IA_64:
9416                   dynamic_section_ia64_val (entry);
9417                   break;
9418                 default:
9419                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9420                   putchar ('\n');
9421                 }
9422             }
9423           break;
9424         }
9425     }
9426
9427   return 1;
9428 }
9429
9430 static char *
9431 get_ver_flags (unsigned int flags)
9432 {
9433   static char buff[32];
9434
9435   buff[0] = 0;
9436
9437   if (flags == 0)
9438     return _("none");
9439
9440   if (flags & VER_FLG_BASE)
9441     strcat (buff, "BASE ");
9442
9443   if (flags & VER_FLG_WEAK)
9444     {
9445       if (flags & VER_FLG_BASE)
9446         strcat (buff, "| ");
9447
9448       strcat (buff, "WEAK ");
9449     }
9450
9451   if (flags & VER_FLG_INFO)
9452     {
9453       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9454         strcat (buff, "| ");
9455
9456       strcat (buff, "INFO ");
9457     }
9458
9459   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9460     strcat (buff, _("| <unknown>"));
9461
9462   return buff;
9463 }
9464
9465 /* Display the contents of the version sections.  */
9466
9467 static int
9468 process_version_sections (FILE * file)
9469 {
9470   Elf_Internal_Shdr * section;
9471   unsigned i;
9472   int found = 0;
9473
9474   if (! do_version)
9475     return 1;
9476
9477   for (i = 0, section = section_headers;
9478        i < elf_header.e_shnum;
9479        i++, section++)
9480     {
9481       switch (section->sh_type)
9482         {
9483         case SHT_GNU_verdef:
9484           {
9485             Elf_External_Verdef * edefs;
9486             unsigned int idx;
9487             unsigned int cnt;
9488             char * endbuf;
9489
9490             found = 1;
9491
9492             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9493                     printable_section_name (section),
9494                     section->sh_info);
9495
9496             printf (_("  Addr: 0x"));
9497             printf_vma (section->sh_addr);
9498             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9499                     (unsigned long) section->sh_offset, section->sh_link,
9500                     printable_section_name_from_index (section->sh_link));
9501
9502             edefs = (Elf_External_Verdef *)
9503                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9504                           _("version definition section"));
9505             if (!edefs)
9506               break;
9507             endbuf = (char *) edefs + section->sh_size;
9508
9509             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9510               {
9511                 char * vstart;
9512                 Elf_External_Verdef * edef;
9513                 Elf_Internal_Verdef ent;
9514                 Elf_External_Verdaux * eaux;
9515                 Elf_Internal_Verdaux aux;
9516                 int j;
9517                 int isum;
9518
9519                 /* Check for very large indicies.  */
9520                 if (idx > (size_t) (endbuf - (char *) edefs))
9521                   break;
9522
9523                 vstart = ((char *) edefs) + idx;
9524                 if (vstart + sizeof (*edef) > endbuf)
9525                   break;
9526
9527                 edef = (Elf_External_Verdef *) vstart;
9528
9529                 ent.vd_version = BYTE_GET (edef->vd_version);
9530                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9531                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9532                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9533                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9534                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9535                 ent.vd_next    = BYTE_GET (edef->vd_next);
9536
9537                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9538                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9539
9540                 printf (_("  Index: %d  Cnt: %d  "),
9541                         ent.vd_ndx, ent.vd_cnt);
9542
9543                 /* Check for overflow.  */
9544                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9545                   break;
9546
9547                 vstart += ent.vd_aux;
9548
9549                 eaux = (Elf_External_Verdaux *) vstart;
9550
9551                 aux.vda_name = BYTE_GET (eaux->vda_name);
9552                 aux.vda_next = BYTE_GET (eaux->vda_next);
9553
9554                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9555                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9556                 else
9557                   printf (_("Name index: %ld\n"), aux.vda_name);
9558
9559                 isum = idx + ent.vd_aux;
9560
9561                 for (j = 1; j < ent.vd_cnt; j++)
9562                   {
9563                     /* Check for overflow.  */
9564                     if (aux.vda_next > (size_t) (endbuf - vstart))
9565                       break;
9566
9567                     isum   += aux.vda_next;
9568                     vstart += aux.vda_next;
9569
9570                     eaux = (Elf_External_Verdaux *) vstart;
9571                     if (vstart + sizeof (*eaux) > endbuf)
9572                       break;
9573
9574                     aux.vda_name = BYTE_GET (eaux->vda_name);
9575                     aux.vda_next = BYTE_GET (eaux->vda_next);
9576
9577                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9578                       printf (_("  %#06x: Parent %d: %s\n"),
9579                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9580                     else
9581                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9582                               isum, j, aux.vda_name);
9583                   }
9584
9585                 if (j < ent.vd_cnt)
9586                   printf (_("  Version def aux past end of section\n"));
9587
9588                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9589                 if (idx + ent.vd_next <= idx)
9590                   break;
9591
9592                 idx += ent.vd_next;
9593               }
9594
9595             if (cnt < section->sh_info)
9596               printf (_("  Version definition past end of section\n"));
9597
9598             free (edefs);
9599           }
9600           break;
9601
9602         case SHT_GNU_verneed:
9603           {
9604             Elf_External_Verneed * eneed;
9605             unsigned int idx;
9606             unsigned int cnt;
9607             char * endbuf;
9608
9609             found = 1;
9610
9611             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9612                     printable_section_name (section), section->sh_info);
9613
9614             printf (_(" Addr: 0x"));
9615             printf_vma (section->sh_addr);
9616             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9617                     (unsigned long) section->sh_offset, section->sh_link,
9618                     printable_section_name_from_index (section->sh_link));
9619
9620             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9621                                                        section->sh_offset, 1,
9622                                                        section->sh_size,
9623                                                        _("Version Needs section"));
9624             if (!eneed)
9625               break;
9626             endbuf = (char *) eneed + section->sh_size;
9627
9628             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9629               {
9630                 Elf_External_Verneed * entry;
9631                 Elf_Internal_Verneed ent;
9632                 int j;
9633                 int isum;
9634                 char * vstart;
9635
9636                 if (idx > (size_t) (endbuf - (char *) eneed))
9637                   break;
9638
9639                 vstart = ((char *) eneed) + idx;
9640                 if (vstart + sizeof (*entry) > endbuf)
9641                   break;
9642
9643                 entry = (Elf_External_Verneed *) vstart;
9644
9645                 ent.vn_version = BYTE_GET (entry->vn_version);
9646                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9647                 ent.vn_file    = BYTE_GET (entry->vn_file);
9648                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9649                 ent.vn_next    = BYTE_GET (entry->vn_next);
9650
9651                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9652
9653                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9654                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9655                 else
9656                   printf (_("  File: %lx"), ent.vn_file);
9657
9658                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9659
9660                 /* Check for overflow.  */
9661                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9662                   break;
9663                 vstart += ent.vn_aux;
9664
9665                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9666                   {
9667                     Elf_External_Vernaux * eaux;
9668                     Elf_Internal_Vernaux aux;
9669
9670                     if (vstart + sizeof (*eaux) > endbuf)
9671                       break;
9672                     eaux = (Elf_External_Vernaux *) vstart;
9673
9674                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9675                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9676                     aux.vna_other = BYTE_GET (eaux->vna_other);
9677                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9678                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9679
9680                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9681                       printf (_("  %#06x:   Name: %s"),
9682                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9683                     else
9684                       printf (_("  %#06x:   Name index: %lx"),
9685                               isum, aux.vna_name);
9686
9687                     printf (_("  Flags: %s  Version: %d\n"),
9688                             get_ver_flags (aux.vna_flags), aux.vna_other);
9689
9690                     /* Check for overflow.  */
9691                     if (aux.vna_next > (size_t) (endbuf - vstart)
9692                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9693                       {
9694                         warn (_("Invalid vna_next field of %lx\n"),
9695                               aux.vna_next);
9696                         j = ent.vn_cnt;
9697                         break;
9698                       }
9699                     isum   += aux.vna_next;
9700                     vstart += aux.vna_next;
9701                   }
9702
9703                 if (j < ent.vn_cnt)
9704                   warn (_("Missing Version Needs auxillary information\n"));
9705
9706                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9707                   {
9708                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9709                     cnt = section->sh_info;
9710                     break;
9711                   }
9712                 idx += ent.vn_next;
9713               }
9714
9715             if (cnt < section->sh_info)
9716               warn (_("Missing Version Needs information\n"));
9717
9718             free (eneed);
9719           }
9720           break;
9721
9722         case SHT_GNU_versym:
9723           {
9724             Elf_Internal_Shdr * link_section;
9725             size_t total;
9726             unsigned int cnt;
9727             unsigned char * edata;
9728             unsigned short * data;
9729             char * strtab;
9730             Elf_Internal_Sym * symbols;
9731             Elf_Internal_Shdr * string_sec;
9732             unsigned long num_syms;
9733             long off;
9734
9735             if (section->sh_link >= elf_header.e_shnum)
9736               break;
9737
9738             link_section = section_headers + section->sh_link;
9739             total = section->sh_size / sizeof (Elf_External_Versym);
9740
9741             if (link_section->sh_link >= elf_header.e_shnum)
9742               break;
9743
9744             found = 1;
9745
9746             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9747             if (symbols == NULL)
9748               break;
9749
9750             string_sec = section_headers + link_section->sh_link;
9751
9752             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9753                                         string_sec->sh_size,
9754                                         _("version string table"));
9755             if (!strtab)
9756               {
9757                 free (symbols);
9758                 break;
9759               }
9760
9761             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9762                     printable_section_name (section), (unsigned long) total);
9763
9764             printf (_(" Addr: "));
9765             printf_vma (section->sh_addr);
9766             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9767                     (unsigned long) section->sh_offset, section->sh_link,
9768                     printable_section_name (link_section));
9769
9770             off = offset_from_vma (file,
9771                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9772                                    total * sizeof (short));
9773             edata = (unsigned char *) get_data (NULL, file, off, total,
9774                                                 sizeof (short),
9775                                                 _("version symbol data"));
9776             if (!edata)
9777               {
9778                 free (strtab);
9779                 free (symbols);
9780                 break;
9781               }
9782
9783             data = (short unsigned int *) cmalloc (total, sizeof (short));
9784
9785             for (cnt = total; cnt --;)
9786               data[cnt] = byte_get (edata + cnt * sizeof (short),
9787                                     sizeof (short));
9788
9789             free (edata);
9790
9791             for (cnt = 0; cnt < total; cnt += 4)
9792               {
9793                 int j, nn;
9794                 int check_def, check_need;
9795                 char * name;
9796
9797                 printf ("  %03x:", cnt);
9798
9799                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9800                   switch (data[cnt + j])
9801                     {
9802                     case 0:
9803                       fputs (_("   0 (*local*)    "), stdout);
9804                       break;
9805
9806                     case 1:
9807                       fputs (_("   1 (*global*)   "), stdout);
9808                       break;
9809
9810                     default:
9811                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9812                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9813
9814                       /* If this index value is greater than the size of the symbols
9815                          array, break to avoid an out-of-bounds read.  */
9816                       if ((unsigned long)(cnt + j) >= num_syms)
9817                         {
9818                           warn (_("invalid index into symbol array\n"));
9819                           break;
9820                         }
9821
9822                       check_def = 1;
9823                       check_need = 1;
9824                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9825                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9826                              != SHT_NOBITS)
9827                         {
9828                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9829                             check_def = 0;
9830                           else
9831                             check_need = 0;
9832                         }
9833
9834                       if (check_need
9835                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9836                         {
9837                           Elf_Internal_Verneed ivn;
9838                           unsigned long offset;
9839
9840                           offset = offset_from_vma
9841                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9842                              sizeof (Elf_External_Verneed));
9843
9844                           do
9845                             {
9846                               Elf_Internal_Vernaux ivna;
9847                               Elf_External_Verneed evn;
9848                               Elf_External_Vernaux evna;
9849                               unsigned long a_off;
9850
9851                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9852                                             _("version need")) == NULL)
9853                                 break;
9854
9855                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9856                               ivn.vn_next = BYTE_GET (evn.vn_next);
9857
9858                               a_off = offset + ivn.vn_aux;
9859
9860                               do
9861                                 {
9862                                   if (get_data (&evna, file, a_off, sizeof (evna),
9863                                                 1, _("version need aux (2)")) == NULL)
9864                                     {
9865                                       ivna.vna_next  = 0;
9866                                       ivna.vna_other = 0;
9867                                     }
9868                                   else
9869                                     {
9870                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9871                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9872                                     }
9873
9874                                   a_off += ivna.vna_next;
9875                                 }
9876                               while (ivna.vna_other != data[cnt + j]
9877                                      && ivna.vna_next != 0);
9878
9879                               if (ivna.vna_other == data[cnt + j])
9880                                 {
9881                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9882
9883                                   if (ivna.vna_name >= string_sec->sh_size)
9884                                     name = _("*invalid*");
9885                                   else
9886                                     name = strtab + ivna.vna_name;
9887                                   nn += printf ("(%s%-*s",
9888                                                 name,
9889                                                 12 - (int) strlen (name),
9890                                                 ")");
9891                                   check_def = 0;
9892                                   break;
9893                                 }
9894
9895                               offset += ivn.vn_next;
9896                             }
9897                           while (ivn.vn_next);
9898                         }
9899
9900                       if (check_def && data[cnt + j] != 0x8001
9901                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9902                         {
9903                           Elf_Internal_Verdef ivd;
9904                           Elf_External_Verdef evd;
9905                           unsigned long offset;
9906
9907                           offset = offset_from_vma
9908                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9909                              sizeof evd);
9910
9911                           do
9912                             {
9913                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9914                                             _("version def")) == NULL)
9915                                 {
9916                                   ivd.vd_next = 0;
9917                                   /* PR 17531: file: 046-1082287-0.004.  */
9918                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9919                                   break;
9920                                 }
9921                               else
9922                                 {
9923                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9924                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9925                                 }
9926
9927                               offset += ivd.vd_next;
9928                             }
9929                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9930                                  && ivd.vd_next != 0);
9931
9932                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9933                             {
9934                               Elf_External_Verdaux evda;
9935                               Elf_Internal_Verdaux ivda;
9936
9937                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9938
9939                               if (get_data (&evda, file,
9940                                             offset - ivd.vd_next + ivd.vd_aux,
9941                                             sizeof (evda), 1,
9942                                             _("version def aux")) == NULL)
9943                                 break;
9944
9945                               ivda.vda_name = BYTE_GET (evda.vda_name);
9946
9947                               if (ivda.vda_name >= string_sec->sh_size)
9948                                 name = _("*invalid*");
9949                               else
9950                                 name = strtab + ivda.vda_name;
9951                               nn += printf ("(%s%-*s",
9952                                             name,
9953                                             12 - (int) strlen (name),
9954                                             ")");
9955                             }
9956                         }
9957
9958                       if (nn < 18)
9959                         printf ("%*c", 18 - nn, ' ');
9960                     }
9961
9962                 putchar ('\n');
9963               }
9964
9965             free (data);
9966             free (strtab);
9967             free (symbols);
9968           }
9969           break;
9970
9971         default:
9972           break;
9973         }
9974     }
9975
9976   if (! found)
9977     printf (_("\nNo version information found in this file.\n"));
9978
9979   return 1;
9980 }
9981
9982 static const char *
9983 get_symbol_binding (unsigned int binding)
9984 {
9985   static char buff[32];
9986
9987   switch (binding)
9988     {
9989     case STB_LOCAL:     return "LOCAL";
9990     case STB_GLOBAL:    return "GLOBAL";
9991     case STB_WEAK:      return "WEAK";
9992     default:
9993       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9994         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9995                   binding);
9996       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9997         {
9998           if (binding == STB_GNU_UNIQUE
9999               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10000                   /* GNU is still using the default value 0.  */
10001                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10002             return "UNIQUE";
10003           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10004         }
10005       else
10006         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10007       return buff;
10008     }
10009 }
10010
10011 static const char *
10012 get_symbol_type (unsigned int type)
10013 {
10014   static char buff[32];
10015
10016   switch (type)
10017     {
10018     case STT_NOTYPE:    return "NOTYPE";
10019     case STT_OBJECT:    return "OBJECT";
10020     case STT_FUNC:      return "FUNC";
10021     case STT_SECTION:   return "SECTION";
10022     case STT_FILE:      return "FILE";
10023     case STT_COMMON:    return "COMMON";
10024     case STT_TLS:       return "TLS";
10025     case STT_RELC:      return "RELC";
10026     case STT_SRELC:     return "SRELC";
10027     default:
10028       if (type >= STT_LOPROC && type <= STT_HIPROC)
10029         {
10030           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10031             return "THUMB_FUNC";
10032
10033           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10034             return "REGISTER";
10035
10036           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10037             return "PARISC_MILLI";
10038
10039           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10040         }
10041       else if (type >= STT_LOOS && type <= STT_HIOS)
10042         {
10043           if (elf_header.e_machine == EM_PARISC)
10044             {
10045               if (type == STT_HP_OPAQUE)
10046                 return "HP_OPAQUE";
10047               if (type == STT_HP_STUB)
10048                 return "HP_STUB";
10049             }
10050
10051           if (type == STT_GNU_IFUNC
10052               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10053                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10054                   /* GNU is still using the default value 0.  */
10055                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10056             return "IFUNC";
10057
10058           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10059         }
10060       else
10061         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10062       return buff;
10063     }
10064 }
10065
10066 static const char *
10067 get_symbol_visibility (unsigned int visibility)
10068 {
10069   switch (visibility)
10070     {
10071     case STV_DEFAULT:   return "DEFAULT";
10072     case STV_INTERNAL:  return "INTERNAL";
10073     case STV_HIDDEN:    return "HIDDEN";
10074     case STV_PROTECTED: return "PROTECTED";
10075     default:
10076       error (_("Unrecognized visibility value: %u"), visibility);
10077       return _("<unknown>");
10078     }
10079 }
10080
10081 static const char *
10082 get_mips_symbol_other (unsigned int other)
10083 {
10084   switch (other)
10085     {
10086     case STO_OPTIONAL:
10087       return "OPTIONAL";
10088     case STO_MIPS_PLT:
10089       return "MIPS PLT";
10090     case STO_MIPS_PIC:
10091       return "MIPS PIC";
10092     case STO_MICROMIPS:
10093       return "MICROMIPS";
10094     case STO_MICROMIPS | STO_MIPS_PIC:
10095       return "MICROMIPS, MIPS PIC";
10096     case STO_MIPS16:
10097       return "MIPS16";
10098     default:
10099       return NULL;
10100     }
10101 }
10102
10103 static const char *
10104 get_ia64_symbol_other (unsigned int other)
10105 {
10106   if (is_ia64_vms ())
10107     {
10108       static char res[32];
10109
10110       res[0] = 0;
10111
10112       /* Function types is for images and .STB files only.  */
10113       switch (elf_header.e_type)
10114         {
10115         case ET_DYN:
10116         case ET_EXEC:
10117           switch (VMS_ST_FUNC_TYPE (other))
10118             {
10119             case VMS_SFT_CODE_ADDR:
10120               strcat (res, " CA");
10121               break;
10122             case VMS_SFT_SYMV_IDX:
10123               strcat (res, " VEC");
10124               break;
10125             case VMS_SFT_FD:
10126               strcat (res, " FD");
10127               break;
10128             case VMS_SFT_RESERVE:
10129               strcat (res, " RSV");
10130               break;
10131             default:
10132               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10133                     VMS_ST_FUNC_TYPE (other));
10134               strcat (res, " <unknown>");
10135               break;
10136             }
10137           break;
10138         default:
10139           break;
10140         }
10141       switch (VMS_ST_LINKAGE (other))
10142         {
10143         case VMS_STL_IGNORE:
10144           strcat (res, " IGN");
10145           break;
10146         case VMS_STL_RESERVE:
10147           strcat (res, " RSV");
10148           break;
10149         case VMS_STL_STD:
10150           strcat (res, " STD");
10151           break;
10152         case VMS_STL_LNK:
10153           strcat (res, " LNK");
10154           break;
10155         default:
10156           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10157                 VMS_ST_LINKAGE (other));
10158           strcat (res, " <unknown>");
10159           break;
10160         }
10161
10162       if (res[0] != 0)
10163         return res + 1;
10164       else
10165         return res;
10166     }
10167   return NULL;
10168 }
10169
10170 static const char *
10171 get_ppc64_symbol_other (unsigned int other)
10172 {
10173   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10174     {
10175       static char buf[32];
10176       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10177                 PPC64_LOCAL_ENTRY_OFFSET (other));
10178       return buf;
10179     }
10180   return NULL;
10181 }
10182
10183 static const char *
10184 get_symbol_other (unsigned int other)
10185 {
10186   const char * result = NULL;
10187   static char buff [32];
10188
10189   if (other == 0)
10190     return "";
10191
10192   switch (elf_header.e_machine)
10193     {
10194     case EM_MIPS:
10195       result = get_mips_symbol_other (other);
10196       break;
10197     case EM_IA_64:
10198       result = get_ia64_symbol_other (other);
10199       break;
10200     case EM_PPC64:
10201       result = get_ppc64_symbol_other (other);
10202       break;
10203     default:
10204       break;
10205     }
10206
10207   if (result)
10208     return result;
10209
10210   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10211   return buff;
10212 }
10213
10214 static const char *
10215 get_symbol_index_type (unsigned int type)
10216 {
10217   static char buff[32];
10218
10219   switch (type)
10220     {
10221     case SHN_UNDEF:     return "UND";
10222     case SHN_ABS:       return "ABS";
10223     case SHN_COMMON:    return "COM";
10224     default:
10225       if (type == SHN_IA_64_ANSI_COMMON
10226           && elf_header.e_machine == EM_IA_64
10227           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10228         return "ANSI_COM";
10229       else if ((elf_header.e_machine == EM_X86_64
10230                 || elf_header.e_machine == EM_L1OM
10231                 || elf_header.e_machine == EM_K1OM)
10232                && type == SHN_X86_64_LCOMMON)
10233         return "LARGE_COM";
10234       else if ((type == SHN_MIPS_SCOMMON
10235                 && elf_header.e_machine == EM_MIPS)
10236                || (type == SHN_TIC6X_SCOMMON
10237                    && elf_header.e_machine == EM_TI_C6000))
10238         return "SCOM";
10239       else if (type == SHN_MIPS_SUNDEFINED
10240                && elf_header.e_machine == EM_MIPS)
10241         return "SUND";
10242       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10243         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10244       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10245         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10246       else if (type >= SHN_LORESERVE)
10247         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10248       else if (type >= elf_header.e_shnum)
10249         sprintf (buff, _("bad section index[%3d]"), type);
10250       else
10251         sprintf (buff, "%3d", type);
10252       break;
10253     }
10254
10255   return buff;
10256 }
10257
10258 static bfd_vma *
10259 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10260 {
10261   unsigned char * e_data;
10262   bfd_vma * i_data;
10263
10264   /* If the size_t type is smaller than the bfd_size_type, eg because
10265      you are building a 32-bit tool on a 64-bit host, then make sure
10266      that when (number) is cast to (size_t) no information is lost.  */
10267   if (sizeof (size_t) < sizeof (bfd_size_type)
10268       && (bfd_size_type) ((size_t) number) != number)
10269     {
10270       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10271              (unsigned long long) number, ent_size);
10272       return NULL;
10273     }
10274
10275   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10276      attempting to allocate memory when the read is bound to fail.  */
10277   if (ent_size * number > current_file_size)
10278     {
10279       error (_("Invalid number of dynamic entries: %llu\n"),
10280              (unsigned long long) number);
10281       return NULL;
10282     }
10283
10284   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10285   if (e_data == NULL)
10286     {
10287       error (_("Out of memory reading %llu dynamic entries\n"),
10288              (unsigned long long) number);
10289       return NULL;
10290     }
10291
10292   if (fread (e_data, ent_size, (size_t) number, file) != number)
10293     {
10294       error (_("Unable to read in %llu bytes of dynamic data\n"),
10295              (unsigned long long) (number * ent_size));
10296       free (e_data);
10297       return NULL;
10298     }
10299
10300   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10301   if (i_data == NULL)
10302     {
10303       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10304              (unsigned long long) number);
10305       free (e_data);
10306       return NULL;
10307     }
10308
10309   while (number--)
10310     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10311
10312   free (e_data);
10313
10314   return i_data;
10315 }
10316
10317 static void
10318 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10319 {
10320   Elf_Internal_Sym * psym;
10321   int n;
10322
10323   n = print_vma (si, DEC_5);
10324   if (n < 5)
10325     fputs (&"     "[n], stdout);
10326   printf (" %3lu: ", hn);
10327
10328   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10329     {
10330       printf (_("<No info available for dynamic symbol number %lu>\n"),
10331               (unsigned long) si);
10332       return;
10333     }
10334
10335   psym = dynamic_symbols + si;
10336   print_vma (psym->st_value, LONG_HEX);
10337   putchar (' ');
10338   print_vma (psym->st_size, DEC_5);
10339
10340   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10341   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10342   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10343   /* Check to see if any other bits in the st_other field are set.
10344      Note - displaying this information disrupts the layout of the
10345      table being generated, but for the moment this case is very
10346      rare.  */
10347   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10348     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10349   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10350   if (VALID_DYNAMIC_NAME (psym->st_name))
10351     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10352   else
10353     printf (_(" <corrupt: %14ld>"), psym->st_name);
10354   putchar ('\n');
10355 }
10356
10357 static const char *
10358 get_symbol_version_string (FILE *file, int is_dynsym,
10359                            const char *strtab,
10360                            unsigned long int strtab_size,
10361                            unsigned int si, Elf_Internal_Sym *psym,
10362                            enum versioned_symbol_info *sym_info,
10363                            unsigned short *vna_other)
10364 {
10365   const char *version_string = NULL;
10366
10367   if (is_dynsym
10368       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10369     {
10370       unsigned char data[2];
10371       unsigned short vers_data;
10372       unsigned long offset;
10373       int is_nobits;
10374       int check_def;
10375
10376       offset = offset_from_vma
10377         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10378          sizeof data + si * sizeof (vers_data));
10379
10380       if (get_data (&data, file, offset + si * sizeof (vers_data),
10381                     sizeof (data), 1, _("version data")) == NULL)
10382         return NULL;
10383
10384       vers_data = byte_get (data, 2);
10385
10386       is_nobits = (section_headers != NULL
10387                    && psym->st_shndx < elf_header.e_shnum
10388                    && section_headers[psym->st_shndx].sh_type
10389                    == SHT_NOBITS);
10390
10391       check_def = (psym->st_shndx != SHN_UNDEF);
10392
10393       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10394         {
10395           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10396               && (is_nobits || ! check_def))
10397             {
10398               Elf_External_Verneed evn;
10399               Elf_Internal_Verneed ivn;
10400               Elf_Internal_Vernaux ivna;
10401
10402               /* We must test both.  */
10403               offset = offset_from_vma
10404                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10405                  sizeof evn);
10406
10407               do
10408                 {
10409                   unsigned long vna_off;
10410
10411                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10412                                 _("version need")) == NULL)
10413                     {
10414                       ivna.vna_next = 0;
10415                       ivna.vna_other = 0;
10416                       ivna.vna_name = 0;
10417                       break;
10418                     }
10419
10420                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10421                   ivn.vn_next = BYTE_GET (evn.vn_next);
10422
10423                   vna_off = offset + ivn.vn_aux;
10424
10425                   do
10426                     {
10427                       Elf_External_Vernaux evna;
10428
10429                       if (get_data (&evna, file, vna_off,
10430                                     sizeof (evna), 1,
10431                                     _("version need aux (3)")) == NULL)
10432                         {
10433                           ivna.vna_next = 0;
10434                           ivna.vna_other = 0;
10435                           ivna.vna_name = 0;
10436                         }
10437                       else
10438                         {
10439                           ivna.vna_other = BYTE_GET (evna.vna_other);
10440                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10441                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10442                         }
10443
10444                       vna_off += ivna.vna_next;
10445                     }
10446                   while (ivna.vna_other != vers_data
10447                          && ivna.vna_next != 0);
10448
10449                   if (ivna.vna_other == vers_data)
10450                     break;
10451
10452                   offset += ivn.vn_next;
10453                 }
10454               while (ivn.vn_next != 0);
10455
10456               if (ivna.vna_other == vers_data)
10457                 {
10458                   *sym_info = symbol_undefined;
10459                   *vna_other = ivna.vna_other;
10460                   version_string = (ivna.vna_name < strtab_size
10461                                     ? strtab + ivna.vna_name
10462                                     : _("<corrupt>"));
10463                   check_def = 0;
10464                 }
10465               else if (! is_nobits)
10466                 error (_("bad dynamic symbol\n"));
10467               else
10468                 check_def = 1;
10469             }
10470
10471           if (check_def)
10472             {
10473               if (vers_data != 0x8001
10474                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10475                 {
10476                   Elf_Internal_Verdef ivd;
10477                   Elf_Internal_Verdaux ivda;
10478                   Elf_External_Verdaux evda;
10479                   unsigned long off;
10480
10481                   off = offset_from_vma
10482                     (file,
10483                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10484                      sizeof (Elf_External_Verdef));
10485
10486                   do
10487                     {
10488                       Elf_External_Verdef evd;
10489
10490                       if (get_data (&evd, file, off, sizeof (evd),
10491                                     1, _("version def")) == NULL)
10492                         {
10493                           ivd.vd_ndx = 0;
10494                           ivd.vd_aux = 0;
10495                           ivd.vd_next = 0;
10496                         }
10497                       else
10498                         {
10499                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10500                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10501                           ivd.vd_next = BYTE_GET (evd.vd_next);
10502                         }
10503
10504                       off += ivd.vd_next;
10505                     }
10506                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10507                          && ivd.vd_next != 0);
10508
10509                   off -= ivd.vd_next;
10510                   off += ivd.vd_aux;
10511
10512                   if (get_data (&evda, file, off, sizeof (evda),
10513                                 1, _("version def aux")) == NULL)
10514                     return version_string;
10515
10516                   ivda.vda_name = BYTE_GET (evda.vda_name);
10517
10518                   if (psym->st_name != ivda.vda_name)
10519                     {
10520                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10521                                    ? symbol_hidden : symbol_public);
10522                       version_string = (ivda.vda_name < strtab_size
10523                                         ? strtab + ivda.vda_name
10524                                         : _("<corrupt>"));
10525                     }
10526                 }
10527             }
10528         }
10529     }
10530   return version_string;
10531 }
10532
10533 /* Dump the symbol table.  */
10534 static int
10535 process_symbol_table (FILE * file)
10536 {
10537   Elf_Internal_Shdr * section;
10538   bfd_size_type nbuckets = 0;
10539   bfd_size_type nchains = 0;
10540   bfd_vma * buckets = NULL;
10541   bfd_vma * chains = NULL;
10542   bfd_vma ngnubuckets = 0;
10543   bfd_vma * gnubuckets = NULL;
10544   bfd_vma * gnuchains = NULL;
10545   bfd_vma gnusymidx = 0;
10546   bfd_size_type ngnuchains = 0;
10547
10548   if (!do_syms && !do_dyn_syms && !do_histogram)
10549     return 1;
10550
10551   if (dynamic_info[DT_HASH]
10552       && (do_histogram
10553           || (do_using_dynamic
10554               && !do_dyn_syms
10555               && dynamic_strings != NULL)))
10556     {
10557       unsigned char nb[8];
10558       unsigned char nc[8];
10559       unsigned int hash_ent_size = 4;
10560
10561       if ((elf_header.e_machine == EM_ALPHA
10562            || elf_header.e_machine == EM_S390
10563            || elf_header.e_machine == EM_S390_OLD)
10564           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10565         hash_ent_size = 8;
10566
10567       if (fseek (file,
10568                  (archive_file_offset
10569                   + offset_from_vma (file, dynamic_info[DT_HASH],
10570                                      sizeof nb + sizeof nc)),
10571                  SEEK_SET))
10572         {
10573           error (_("Unable to seek to start of dynamic information\n"));
10574           goto no_hash;
10575         }
10576
10577       if (fread (nb, hash_ent_size, 1, file) != 1)
10578         {
10579           error (_("Failed to read in number of buckets\n"));
10580           goto no_hash;
10581         }
10582
10583       if (fread (nc, hash_ent_size, 1, file) != 1)
10584         {
10585           error (_("Failed to read in number of chains\n"));
10586           goto no_hash;
10587         }
10588
10589       nbuckets = byte_get (nb, hash_ent_size);
10590       nchains  = byte_get (nc, hash_ent_size);
10591
10592       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10593       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10594
10595     no_hash:
10596       if (buckets == NULL || chains == NULL)
10597         {
10598           if (do_using_dynamic)
10599             return 0;
10600           free (buckets);
10601           free (chains);
10602           buckets = NULL;
10603           chains = NULL;
10604           nbuckets = 0;
10605           nchains = 0;
10606         }
10607     }
10608
10609   if (dynamic_info_DT_GNU_HASH
10610       && (do_histogram
10611           || (do_using_dynamic
10612               && !do_dyn_syms
10613               && dynamic_strings != NULL)))
10614     {
10615       unsigned char nb[16];
10616       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10617       bfd_vma buckets_vma;
10618
10619       if (fseek (file,
10620                  (archive_file_offset
10621                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10622                                      sizeof nb)),
10623                  SEEK_SET))
10624         {
10625           error (_("Unable to seek to start of dynamic information\n"));
10626           goto no_gnu_hash;
10627         }
10628
10629       if (fread (nb, 16, 1, file) != 1)
10630         {
10631           error (_("Failed to read in number of buckets\n"));
10632           goto no_gnu_hash;
10633         }
10634
10635       ngnubuckets = byte_get (nb, 4);
10636       gnusymidx = byte_get (nb + 4, 4);
10637       bitmaskwords = byte_get (nb + 8, 4);
10638       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10639       if (is_32bit_elf)
10640         buckets_vma += bitmaskwords * 4;
10641       else
10642         buckets_vma += bitmaskwords * 8;
10643
10644       if (fseek (file,
10645                  (archive_file_offset
10646                   + offset_from_vma (file, buckets_vma, 4)),
10647                  SEEK_SET))
10648         {
10649           error (_("Unable to seek to start of dynamic information\n"));
10650           goto no_gnu_hash;
10651         }
10652
10653       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10654
10655       if (gnubuckets == NULL)
10656         goto no_gnu_hash;
10657
10658       for (i = 0; i < ngnubuckets; i++)
10659         if (gnubuckets[i] != 0)
10660           {
10661             if (gnubuckets[i] < gnusymidx)
10662               return 0;
10663
10664             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10665               maxchain = gnubuckets[i];
10666           }
10667
10668       if (maxchain == 0xffffffff)
10669         goto no_gnu_hash;
10670
10671       maxchain -= gnusymidx;
10672
10673       if (fseek (file,
10674                  (archive_file_offset
10675                   + offset_from_vma (file, buckets_vma
10676                                            + 4 * (ngnubuckets + maxchain), 4)),
10677                  SEEK_SET))
10678         {
10679           error (_("Unable to seek to start of dynamic information\n"));
10680           goto no_gnu_hash;
10681         }
10682
10683       do
10684         {
10685           if (fread (nb, 4, 1, file) != 1)
10686             {
10687               error (_("Failed to determine last chain length\n"));
10688               goto no_gnu_hash;
10689             }
10690
10691           if (maxchain + 1 == 0)
10692             goto no_gnu_hash;
10693
10694           ++maxchain;
10695         }
10696       while ((byte_get (nb, 4) & 1) == 0);
10697
10698       if (fseek (file,
10699                  (archive_file_offset
10700                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10701                  SEEK_SET))
10702         {
10703           error (_("Unable to seek to start of dynamic information\n"));
10704           goto no_gnu_hash;
10705         }
10706
10707       gnuchains = get_dynamic_data (file, maxchain, 4);
10708       ngnuchains = maxchain;
10709
10710     no_gnu_hash:
10711       if (gnuchains == NULL)
10712         {
10713           free (gnubuckets);
10714           gnubuckets = NULL;
10715           ngnubuckets = 0;
10716           if (do_using_dynamic)
10717             return 0;
10718         }
10719     }
10720
10721   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10722       && do_syms
10723       && do_using_dynamic
10724       && dynamic_strings != NULL
10725       && dynamic_symbols != NULL)
10726     {
10727       unsigned long hn;
10728
10729       if (dynamic_info[DT_HASH])
10730         {
10731           bfd_vma si;
10732
10733           printf (_("\nSymbol table for image:\n"));
10734           if (is_32bit_elf)
10735             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10736           else
10737             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10738
10739           for (hn = 0; hn < nbuckets; hn++)
10740             {
10741               if (! buckets[hn])
10742                 continue;
10743
10744               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10745                 print_dynamic_symbol (si, hn);
10746             }
10747         }
10748
10749       if (dynamic_info_DT_GNU_HASH)
10750         {
10751           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10752           if (is_32bit_elf)
10753             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10754           else
10755             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10756
10757           for (hn = 0; hn < ngnubuckets; ++hn)
10758             if (gnubuckets[hn] != 0)
10759               {
10760                 bfd_vma si = gnubuckets[hn];
10761                 bfd_vma off = si - gnusymidx;
10762
10763                 do
10764                   {
10765                     print_dynamic_symbol (si, hn);
10766                     si++;
10767                   }
10768                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10769               }
10770         }
10771     }
10772   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10773            && section_headers != NULL)
10774     {
10775       unsigned int i;
10776
10777       for (i = 0, section = section_headers;
10778            i < elf_header.e_shnum;
10779            i++, section++)
10780         {
10781           unsigned int si;
10782           char * strtab = NULL;
10783           unsigned long int strtab_size = 0;
10784           Elf_Internal_Sym * symtab;
10785           Elf_Internal_Sym * psym;
10786           unsigned long num_syms;
10787
10788           if ((section->sh_type != SHT_SYMTAB
10789                && section->sh_type != SHT_DYNSYM)
10790               || (!do_syms
10791                   && section->sh_type == SHT_SYMTAB))
10792             continue;
10793
10794           if (section->sh_entsize == 0)
10795             {
10796               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10797                       printable_section_name (section));
10798               continue;
10799             }
10800
10801           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10802                   printable_section_name (section),
10803                   (unsigned long) (section->sh_size / section->sh_entsize));
10804
10805           if (is_32bit_elf)
10806             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10807           else
10808             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10809
10810           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10811           if (symtab == NULL)
10812             continue;
10813
10814           if (section->sh_link == elf_header.e_shstrndx)
10815             {
10816               strtab = string_table;
10817               strtab_size = string_table_length;
10818             }
10819           else if (section->sh_link < elf_header.e_shnum)
10820             {
10821               Elf_Internal_Shdr * string_sec;
10822
10823               string_sec = section_headers + section->sh_link;
10824
10825               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10826                                           1, string_sec->sh_size,
10827                                           _("string table"));
10828               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10829             }
10830
10831           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10832             {
10833               const char *version_string;
10834               enum versioned_symbol_info sym_info;
10835               unsigned short vna_other;
10836
10837               printf ("%6d: ", si);
10838               print_vma (psym->st_value, LONG_HEX);
10839               putchar (' ');
10840               print_vma (psym->st_size, DEC_5);
10841               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10842               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10843               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10844               /* Check to see if any other bits in the st_other field are set.
10845                  Note - displaying this information disrupts the layout of the
10846                  table being generated, but for the moment this case is very rare.  */
10847               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10848                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10849               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10850               print_symbol (25, psym->st_name < strtab_size
10851                             ? strtab + psym->st_name : _("<corrupt>"));
10852
10853               version_string
10854                 = get_symbol_version_string (file,
10855                                              section->sh_type == SHT_DYNSYM,
10856                                              strtab, strtab_size, si,
10857                                              psym, &sym_info, &vna_other);
10858               if (version_string)
10859                 {
10860                   if (sym_info == symbol_undefined)
10861                     printf ("@%s (%d)", version_string, vna_other);
10862                   else
10863                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10864                             version_string);
10865                 }
10866
10867               putchar ('\n');
10868             }
10869
10870           free (symtab);
10871           if (strtab != string_table)
10872             free (strtab);
10873         }
10874     }
10875   else if (do_syms)
10876     printf
10877       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10878
10879   if (do_histogram && buckets != NULL)
10880     {
10881       unsigned long * lengths;
10882       unsigned long * counts;
10883       unsigned long hn;
10884       bfd_vma si;
10885       unsigned long maxlength = 0;
10886       unsigned long nzero_counts = 0;
10887       unsigned long nsyms = 0;
10888       unsigned long chained;
10889
10890       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10891               (unsigned long) nbuckets);
10892
10893       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10894       if (lengths == NULL)
10895         {
10896           error (_("Out of memory allocating space for histogram buckets\n"));
10897           return 0;
10898         }
10899
10900       printf (_(" Length  Number     %% of total  Coverage\n"));
10901       for (hn = 0; hn < nbuckets; ++hn)
10902         {
10903           for (si = buckets[hn], chained = 0;
10904                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10905                si = chains[si], ++chained)
10906             {
10907               ++nsyms;
10908               if (maxlength < ++lengths[hn])
10909                 ++maxlength;
10910             }
10911
10912             /* PR binutils/17531: A corrupt binary could contain broken
10913                histogram data.  Do not go into an infinite loop trying
10914                to process it.  */
10915             if (chained > nchains)
10916               {
10917                 error (_("histogram chain is corrupt\n"));
10918                 break;
10919               }
10920         }
10921
10922       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10923       if (counts == NULL)
10924         {
10925           free (lengths);
10926           error (_("Out of memory allocating space for histogram counts\n"));
10927           return 0;
10928         }
10929
10930       for (hn = 0; hn < nbuckets; ++hn)
10931         ++counts[lengths[hn]];
10932
10933       if (nbuckets > 0)
10934         {
10935           unsigned long i;
10936           printf ("      0  %-10lu (%5.1f%%)\n",
10937                   counts[0], (counts[0] * 100.0) / nbuckets);
10938           for (i = 1; i <= maxlength; ++i)
10939             {
10940               nzero_counts += counts[i] * i;
10941               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10942                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10943                       (nzero_counts * 100.0) / nsyms);
10944             }
10945         }
10946
10947       free (counts);
10948       free (lengths);
10949     }
10950
10951   if (buckets != NULL)
10952     {
10953       free (buckets);
10954       free (chains);
10955     }
10956
10957   if (do_histogram && gnubuckets != NULL)
10958     {
10959       unsigned long * lengths;
10960       unsigned long * counts;
10961       unsigned long hn;
10962       unsigned long maxlength = 0;
10963       unsigned long nzero_counts = 0;
10964       unsigned long nsyms = 0;
10965
10966       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10967               (unsigned long) ngnubuckets);
10968
10969       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10970       if (lengths == NULL)
10971         {
10972           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10973           return 0;
10974         }
10975
10976       printf (_(" Length  Number     %% of total  Coverage\n"));
10977
10978       for (hn = 0; hn < ngnubuckets; ++hn)
10979         if (gnubuckets[hn] != 0)
10980           {
10981             bfd_vma off, length = 1;
10982
10983             for (off = gnubuckets[hn] - gnusymidx;
10984                  /* PR 17531 file: 010-77222-0.004.  */
10985                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10986                  ++off)
10987               ++length;
10988             lengths[hn] = length;
10989             if (length > maxlength)
10990               maxlength = length;
10991             nsyms += length;
10992           }
10993
10994       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10995       if (counts == NULL)
10996         {
10997           free (lengths);
10998           error (_("Out of memory allocating space for gnu histogram counts\n"));
10999           return 0;
11000         }
11001
11002       for (hn = 0; hn < ngnubuckets; ++hn)
11003         ++counts[lengths[hn]];
11004
11005       if (ngnubuckets > 0)
11006         {
11007           unsigned long j;
11008           printf ("      0  %-10lu (%5.1f%%)\n",
11009                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11010           for (j = 1; j <= maxlength; ++j)
11011             {
11012               nzero_counts += counts[j] * j;
11013               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11014                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11015                       (nzero_counts * 100.0) / nsyms);
11016             }
11017         }
11018
11019       free (counts);
11020       free (lengths);
11021       free (gnubuckets);
11022       free (gnuchains);
11023     }
11024
11025   return 1;
11026 }
11027
11028 static int
11029 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11030 {
11031   unsigned int i;
11032
11033   if (dynamic_syminfo == NULL
11034       || !do_dynamic)
11035     /* No syminfo, this is ok.  */
11036     return 1;
11037
11038   /* There better should be a dynamic symbol section.  */
11039   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11040     return 0;
11041
11042   if (dynamic_addr)
11043     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11044             dynamic_syminfo_offset, dynamic_syminfo_nent);
11045
11046   printf (_(" Num: Name                           BoundTo     Flags\n"));
11047   for (i = 0; i < dynamic_syminfo_nent; ++i)
11048     {
11049       unsigned short int flags = dynamic_syminfo[i].si_flags;
11050
11051       printf ("%4d: ", i);
11052       if (i >= num_dynamic_syms)
11053         printf (_("<corrupt index>"));
11054       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11055         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11056       else
11057         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11058       putchar (' ');
11059
11060       switch (dynamic_syminfo[i].si_boundto)
11061         {
11062         case SYMINFO_BT_SELF:
11063           fputs ("SELF       ", stdout);
11064           break;
11065         case SYMINFO_BT_PARENT:
11066           fputs ("PARENT     ", stdout);
11067           break;
11068         default:
11069           if (dynamic_syminfo[i].si_boundto > 0
11070               && dynamic_syminfo[i].si_boundto < dynamic_nent
11071               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11072             {
11073               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11074               putchar (' ' );
11075             }
11076           else
11077             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11078           break;
11079         }
11080
11081       if (flags & SYMINFO_FLG_DIRECT)
11082         printf (" DIRECT");
11083       if (flags & SYMINFO_FLG_PASSTHRU)
11084         printf (" PASSTHRU");
11085       if (flags & SYMINFO_FLG_COPY)
11086         printf (" COPY");
11087       if (flags & SYMINFO_FLG_LAZYLOAD)
11088         printf (" LAZYLOAD");
11089
11090       puts ("");
11091     }
11092
11093   return 1;
11094 }
11095
11096 /* Check to see if the given reloc needs to be handled in a target specific
11097    manner.  If so then process the reloc and return TRUE otherwise return
11098    FALSE.  */
11099
11100 static bfd_boolean
11101 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11102                                 unsigned char *     start,
11103                                 Elf_Internal_Sym *  symtab)
11104 {
11105   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11106
11107   switch (elf_header.e_machine)
11108     {
11109     case EM_MSP430:
11110     case EM_MSP430_OLD:
11111       {
11112         static Elf_Internal_Sym * saved_sym = NULL;
11113
11114         switch (reloc_type)
11115           {
11116           case 10: /* R_MSP430_SYM_DIFF */
11117             if (uses_msp430x_relocs ())
11118               break;
11119           case 21: /* R_MSP430X_SYM_DIFF */
11120             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11121             return TRUE;
11122
11123           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11124           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11125             goto handle_sym_diff;
11126
11127           case 5: /* R_MSP430_16_BYTE */
11128           case 9: /* R_MSP430_8 */
11129             if (uses_msp430x_relocs ())
11130               break;
11131             goto handle_sym_diff;
11132
11133           case 2: /* R_MSP430_ABS16 */
11134           case 15: /* R_MSP430X_ABS16 */
11135             if (! uses_msp430x_relocs ())
11136               break;
11137             goto handle_sym_diff;
11138
11139           handle_sym_diff:
11140             if (saved_sym != NULL)
11141               {
11142                 bfd_vma value;
11143
11144                 value = reloc->r_addend
11145                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11146                      - saved_sym->st_value);
11147
11148                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11149
11150                 saved_sym = NULL;
11151                 return TRUE;
11152               }
11153             break;
11154
11155           default:
11156             if (saved_sym != NULL)
11157               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11158             break;
11159           }
11160         break;
11161       }
11162
11163     case EM_MN10300:
11164     case EM_CYGNUS_MN10300:
11165       {
11166         static Elf_Internal_Sym * saved_sym = NULL;
11167
11168         switch (reloc_type)
11169           {
11170           case 34: /* R_MN10300_ALIGN */
11171             return TRUE;
11172           case 33: /* R_MN10300_SYM_DIFF */
11173             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11174             return TRUE;
11175           case 1: /* R_MN10300_32 */
11176           case 2: /* R_MN10300_16 */
11177             if (saved_sym != NULL)
11178               {
11179                 bfd_vma value;
11180
11181                 value = reloc->r_addend
11182                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11183                      - saved_sym->st_value);
11184
11185                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11186
11187                 saved_sym = NULL;
11188                 return TRUE;
11189               }
11190             break;
11191           default:
11192             if (saved_sym != NULL)
11193               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11194             break;
11195           }
11196         break;
11197       }
11198
11199     case EM_RL78:
11200       {
11201         static bfd_vma saved_sym1 = 0;
11202         static bfd_vma saved_sym2 = 0;
11203         static bfd_vma value;
11204
11205         switch (reloc_type)
11206           {
11207           case 0x80: /* R_RL78_SYM.  */
11208             saved_sym1 = saved_sym2;
11209             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11210             saved_sym2 += reloc->r_addend;
11211             return TRUE;
11212
11213           case 0x83: /* R_RL78_OPsub.  */
11214             value = saved_sym1 - saved_sym2;
11215             saved_sym2 = saved_sym1 = 0;
11216             return TRUE;
11217             break;
11218
11219           case 0x41: /* R_RL78_ABS32.  */
11220             byte_put (start + reloc->r_offset, value, 4);
11221             value = 0;
11222             return TRUE;
11223
11224           case 0x43: /* R_RL78_ABS16.  */
11225             byte_put (start + reloc->r_offset, value, 2);
11226             value = 0;
11227             return TRUE;
11228
11229           default:
11230             break;
11231           }
11232         break;
11233       }
11234     }
11235
11236   return FALSE;
11237 }
11238
11239 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11240    DWARF debug sections.  This is a target specific test.  Note - we do not
11241    go through the whole including-target-headers-multiple-times route, (as
11242    we have already done with <elf/h8.h>) because this would become very
11243    messy and even then this function would have to contain target specific
11244    information (the names of the relocs instead of their numeric values).
11245    FIXME: This is not the correct way to solve this problem.  The proper way
11246    is to have target specific reloc sizing and typing functions created by
11247    the reloc-macros.h header, in the same way that it already creates the
11248    reloc naming functions.  */
11249
11250 static bfd_boolean
11251 is_32bit_abs_reloc (unsigned int reloc_type)
11252 {
11253   switch (elf_header.e_machine)
11254     {
11255     case EM_386:
11256     case EM_486:
11257       return reloc_type == 1; /* R_386_32.  */
11258     case EM_68K:
11259       return reloc_type == 1; /* R_68K_32.  */
11260     case EM_860:
11261       return reloc_type == 1; /* R_860_32.  */
11262     case EM_960:
11263       return reloc_type == 2; /* R_960_32.  */
11264     case EM_AARCH64:
11265       return reloc_type == 258; /* R_AARCH64_ABS32 */
11266     case EM_ALPHA:
11267       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11268     case EM_ARC:
11269       return reloc_type == 1; /* R_ARC_32.  */
11270     case EM_ARM:
11271       return reloc_type == 2; /* R_ARM_ABS32 */
11272     case EM_AVR_OLD:
11273     case EM_AVR:
11274       return reloc_type == 1;
11275     case EM_ADAPTEVA_EPIPHANY:
11276       return reloc_type == 3;
11277     case EM_BLACKFIN:
11278       return reloc_type == 0x12; /* R_byte4_data.  */
11279     case EM_CRIS:
11280       return reloc_type == 3; /* R_CRIS_32.  */
11281     case EM_CR16:
11282       return reloc_type == 3; /* R_CR16_NUM32.  */
11283     case EM_CRX:
11284       return reloc_type == 15; /* R_CRX_NUM32.  */
11285     case EM_CYGNUS_FRV:
11286       return reloc_type == 1;
11287     case EM_CYGNUS_D10V:
11288     case EM_D10V:
11289       return reloc_type == 6; /* R_D10V_32.  */
11290     case EM_CYGNUS_D30V:
11291     case EM_D30V:
11292       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11293     case EM_DLX:
11294       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11295     case EM_CYGNUS_FR30:
11296     case EM_FR30:
11297       return reloc_type == 3; /* R_FR30_32.  */
11298     case EM_FT32:
11299       return reloc_type == 1; /* R_FT32_32.  */
11300     case EM_H8S:
11301     case EM_H8_300:
11302     case EM_H8_300H:
11303       return reloc_type == 1; /* R_H8_DIR32.  */
11304     case EM_IA_64:
11305       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
11306     case EM_IP2K_OLD:
11307     case EM_IP2K:
11308       return reloc_type == 2; /* R_IP2K_32.  */
11309     case EM_IQ2000:
11310       return reloc_type == 2; /* R_IQ2000_32.  */
11311     case EM_LATTICEMICO32:
11312       return reloc_type == 3; /* R_LM32_32.  */
11313     case EM_M32C_OLD:
11314     case EM_M32C:
11315       return reloc_type == 3; /* R_M32C_32.  */
11316     case EM_M32R:
11317       return reloc_type == 34; /* R_M32R_32_RELA.  */
11318     case EM_MCORE:
11319       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11320     case EM_CYGNUS_MEP:
11321       return reloc_type == 4; /* R_MEP_32.  */
11322     case EM_METAG:
11323       return reloc_type == 2; /* R_METAG_ADDR32.  */
11324     case EM_MICROBLAZE:
11325       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11326     case EM_MIPS:
11327       return reloc_type == 2; /* R_MIPS_32.  */
11328     case EM_MMIX:
11329       return reloc_type == 4; /* R_MMIX_32.  */
11330     case EM_CYGNUS_MN10200:
11331     case EM_MN10200:
11332       return reloc_type == 1; /* R_MN10200_32.  */
11333     case EM_CYGNUS_MN10300:
11334     case EM_MN10300:
11335       return reloc_type == 1; /* R_MN10300_32.  */
11336     case EM_MOXIE:
11337       return reloc_type == 1; /* R_MOXIE_32.  */
11338     case EM_MSP430_OLD:
11339     case EM_MSP430:
11340       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11341     case EM_MT:
11342       return reloc_type == 2; /* R_MT_32.  */
11343     case EM_NDS32:
11344       return reloc_type == 20; /* R_NDS32_RELA.  */
11345     case EM_ALTERA_NIOS2:
11346       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11347     case EM_NIOS32:
11348       return reloc_type == 1; /* R_NIOS_32.  */
11349     case EM_OR1K:
11350       return reloc_type == 1; /* R_OR1K_32.  */
11351     case EM_PARISC:
11352       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11353               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11354     case EM_PJ:
11355     case EM_PJ_OLD:
11356       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11357     case EM_PPC64:
11358       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11359     case EM_PPC:
11360       return reloc_type == 1; /* R_PPC_ADDR32.  */
11361     case EM_RL78:
11362       return reloc_type == 1; /* R_RL78_DIR32.  */
11363     case EM_RX:
11364       return reloc_type == 1; /* R_RX_DIR32.  */
11365     case EM_S370:
11366       return reloc_type == 1; /* R_I370_ADDR31.  */
11367     case EM_S390_OLD:
11368     case EM_S390:
11369       return reloc_type == 4; /* R_S390_32.  */
11370     case EM_SCORE:
11371       return reloc_type == 8; /* R_SCORE_ABS32.  */
11372     case EM_SH:
11373       return reloc_type == 1; /* R_SH_DIR32.  */
11374     case EM_SPARC32PLUS:
11375     case EM_SPARCV9:
11376     case EM_SPARC:
11377       return reloc_type == 3 /* R_SPARC_32.  */
11378         || reloc_type == 23; /* R_SPARC_UA32.  */
11379     case EM_SPU:
11380       return reloc_type == 6; /* R_SPU_ADDR32 */
11381     case EM_TI_C6000:
11382       return reloc_type == 1; /* R_C6000_ABS32.  */
11383     case EM_TILEGX:
11384       return reloc_type == 2; /* R_TILEGX_32.  */
11385     case EM_TILEPRO:
11386       return reloc_type == 1; /* R_TILEPRO_32.  */
11387     case EM_CYGNUS_V850:
11388     case EM_V850:
11389       return reloc_type == 6; /* R_V850_ABS32.  */
11390     case EM_V800:
11391       return reloc_type == 0x33; /* R_V810_WORD.  */
11392     case EM_VAX:
11393       return reloc_type == 1; /* R_VAX_32.  */
11394     case EM_VISIUM:
11395       return reloc_type == 3;  /* R_VISIUM_32. */
11396     case EM_X86_64:
11397     case EM_L1OM:
11398     case EM_K1OM:
11399       return reloc_type == 10; /* R_X86_64_32.  */
11400     case EM_XC16X:
11401     case EM_C166:
11402       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11403     case EM_XGATE:
11404       return reloc_type == 4; /* R_XGATE_32.  */
11405     case EM_XSTORMY16:
11406       return reloc_type == 1; /* R_XSTROMY16_32.  */
11407     case EM_XTENSA_OLD:
11408     case EM_XTENSA:
11409       return reloc_type == 1; /* R_XTENSA_32.  */
11410     default:
11411       {
11412         static unsigned int prev_warn = 0;
11413
11414         /* Avoid repeating the same warning multiple times.  */
11415         if (prev_warn != elf_header.e_machine)
11416           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11417                  elf_header.e_machine);
11418         prev_warn = elf_header.e_machine;
11419         return FALSE;
11420       }
11421     }
11422 }
11423
11424 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11425    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11426
11427 static bfd_boolean
11428 is_32bit_pcrel_reloc (unsigned int reloc_type)
11429 {
11430   switch (elf_header.e_machine)
11431     {
11432     case EM_386:
11433     case EM_486:
11434       return reloc_type == 2;  /* R_386_PC32.  */
11435     case EM_68K:
11436       return reloc_type == 4;  /* R_68K_PC32.  */
11437     case EM_AARCH64:
11438       return reloc_type == 261; /* R_AARCH64_PREL32 */
11439     case EM_ADAPTEVA_EPIPHANY:
11440       return reloc_type == 6;
11441     case EM_ALPHA:
11442       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11443     case EM_ARM:
11444       return reloc_type == 3;  /* R_ARM_REL32 */
11445     case EM_MICROBLAZE:
11446       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11447     case EM_OR1K:
11448       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11449     case EM_PARISC:
11450       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11451     case EM_PPC:
11452       return reloc_type == 26; /* R_PPC_REL32.  */
11453     case EM_PPC64:
11454       return reloc_type == 26; /* R_PPC64_REL32.  */
11455     case EM_S390_OLD:
11456     case EM_S390:
11457       return reloc_type == 5;  /* R_390_PC32.  */
11458     case EM_SH:
11459       return reloc_type == 2;  /* R_SH_REL32.  */
11460     case EM_SPARC32PLUS:
11461     case EM_SPARCV9:
11462     case EM_SPARC:
11463       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11464     case EM_SPU:
11465       return reloc_type == 13; /* R_SPU_REL32.  */
11466     case EM_TILEGX:
11467       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11468     case EM_TILEPRO:
11469       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11470     case EM_VISIUM:
11471       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11472     case EM_X86_64:
11473     case EM_L1OM:
11474     case EM_K1OM:
11475       return reloc_type == 2;  /* R_X86_64_PC32.  */
11476     case EM_XTENSA_OLD:
11477     case EM_XTENSA:
11478       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11479     default:
11480       /* Do not abort or issue an error message here.  Not all targets use
11481          pc-relative 32-bit relocs in their DWARF debug information and we
11482          have already tested for target coverage in is_32bit_abs_reloc.  A
11483          more helpful warning message will be generated by apply_relocations
11484          anyway, so just return.  */
11485       return FALSE;
11486     }
11487 }
11488
11489 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11490    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11491
11492 static bfd_boolean
11493 is_64bit_abs_reloc (unsigned int reloc_type)
11494 {
11495   switch (elf_header.e_machine)
11496     {
11497     case EM_AARCH64:
11498       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11499     case EM_ALPHA:
11500       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11501     case EM_IA_64:
11502       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11503     case EM_PARISC:
11504       return reloc_type == 80; /* R_PARISC_DIR64.  */
11505     case EM_PPC64:
11506       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11507     case EM_SPARC32PLUS:
11508     case EM_SPARCV9:
11509     case EM_SPARC:
11510       return reloc_type == 54; /* R_SPARC_UA64.  */
11511     case EM_X86_64:
11512     case EM_L1OM:
11513     case EM_K1OM:
11514       return reloc_type == 1; /* R_X86_64_64.  */
11515     case EM_S390_OLD:
11516     case EM_S390:
11517       return reloc_type == 22;  /* R_S390_64.  */
11518     case EM_TILEGX:
11519       return reloc_type == 1; /* R_TILEGX_64.  */
11520     case EM_MIPS:
11521       return reloc_type == 18;  /* R_MIPS_64.  */
11522     default:
11523       return FALSE;
11524     }
11525 }
11526
11527 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11528    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11529
11530 static bfd_boolean
11531 is_64bit_pcrel_reloc (unsigned int reloc_type)
11532 {
11533   switch (elf_header.e_machine)
11534     {
11535     case EM_AARCH64:
11536       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11537     case EM_ALPHA:
11538       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11539     case EM_IA_64:
11540       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11541     case EM_PARISC:
11542       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11543     case EM_PPC64:
11544       return reloc_type == 44; /* R_PPC64_REL64.  */
11545     case EM_SPARC32PLUS:
11546     case EM_SPARCV9:
11547     case EM_SPARC:
11548       return reloc_type == 46; /* R_SPARC_DISP64.  */
11549     case EM_X86_64:
11550     case EM_L1OM:
11551     case EM_K1OM:
11552       return reloc_type == 24; /* R_X86_64_PC64.  */
11553     case EM_S390_OLD:
11554     case EM_S390:
11555       return reloc_type == 23;  /* R_S390_PC64.  */
11556     case EM_TILEGX:
11557       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11558     default:
11559       return FALSE;
11560     }
11561 }
11562
11563 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11564    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11565
11566 static bfd_boolean
11567 is_24bit_abs_reloc (unsigned int reloc_type)
11568 {
11569   switch (elf_header.e_machine)
11570     {
11571     case EM_CYGNUS_MN10200:
11572     case EM_MN10200:
11573       return reloc_type == 4; /* R_MN10200_24.  */
11574     default:
11575       return FALSE;
11576     }
11577 }
11578
11579 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11580    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11581
11582 static bfd_boolean
11583 is_16bit_abs_reloc (unsigned int reloc_type)
11584 {
11585   switch (elf_header.e_machine)
11586     {
11587     case EM_AVR_OLD:
11588     case EM_AVR:
11589       return reloc_type == 4; /* R_AVR_16.  */
11590     case EM_ADAPTEVA_EPIPHANY:
11591       return reloc_type == 5;
11592     case EM_CYGNUS_D10V:
11593     case EM_D10V:
11594       return reloc_type == 3; /* R_D10V_16.  */
11595     case EM_H8S:
11596     case EM_H8_300:
11597     case EM_H8_300H:
11598       return reloc_type == R_H8_DIR16;
11599     case EM_IP2K_OLD:
11600     case EM_IP2K:
11601       return reloc_type == 1; /* R_IP2K_16.  */
11602     case EM_M32C_OLD:
11603     case EM_M32C:
11604       return reloc_type == 1; /* R_M32C_16 */
11605     case EM_MSP430:
11606       if (uses_msp430x_relocs ())
11607         return reloc_type == 2; /* R_MSP430_ABS16.  */
11608     case EM_MSP430_OLD:
11609       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11610     case EM_NDS32:
11611       return reloc_type == 19; /* R_NDS32_RELA.  */
11612     case EM_ALTERA_NIOS2:
11613       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11614     case EM_NIOS32:
11615       return reloc_type == 9; /* R_NIOS_16.  */
11616     case EM_OR1K:
11617       return reloc_type == 2; /* R_OR1K_16.  */
11618     case EM_TI_C6000:
11619       return reloc_type == 2; /* R_C6000_ABS16.  */
11620     case EM_XC16X:
11621     case EM_C166:
11622       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11623     case EM_CYGNUS_MN10200:
11624     case EM_MN10200:
11625       return reloc_type == 2; /* R_MN10200_16.  */
11626     case EM_CYGNUS_MN10300:
11627     case EM_MN10300:
11628       return reloc_type == 2; /* R_MN10300_16.  */
11629     case EM_VISIUM:
11630       return reloc_type == 2; /* R_VISIUM_16. */
11631     case EM_XGATE:
11632       return reloc_type == 3; /* R_XGATE_16.  */
11633     default:
11634       return FALSE;
11635     }
11636 }
11637
11638 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11639    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11640
11641 static bfd_boolean
11642 is_none_reloc (unsigned int reloc_type)
11643 {
11644   switch (elf_header.e_machine)
11645     {
11646     case EM_68K:     /* R_68K_NONE.  */
11647     case EM_386:     /* R_386_NONE.  */
11648     case EM_SPARC32PLUS:
11649     case EM_SPARCV9:
11650     case EM_SPARC:   /* R_SPARC_NONE.  */
11651     case EM_MIPS:    /* R_MIPS_NONE.  */
11652     case EM_PARISC:  /* R_PARISC_NONE.  */
11653     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11654     case EM_ADAPTEVA_EPIPHANY:
11655     case EM_PPC:     /* R_PPC_NONE.  */
11656     case EM_PPC64:   /* R_PPC64_NONE.  */
11657     case EM_ARM:     /* R_ARM_NONE.  */
11658     case EM_IA_64:   /* R_IA64_NONE.  */
11659     case EM_SH:      /* R_SH_NONE.  */
11660     case EM_S390_OLD:
11661     case EM_S390:    /* R_390_NONE.  */
11662     case EM_CRIS:    /* R_CRIS_NONE.  */
11663     case EM_X86_64:  /* R_X86_64_NONE.  */
11664     case EM_L1OM:    /* R_X86_64_NONE.  */
11665     case EM_K1OM:    /* R_X86_64_NONE.  */
11666     case EM_MN10300: /* R_MN10300_NONE.  */
11667     case EM_FT32:    /* R_FT32_NONE.  */
11668     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11669     case EM_M32R:    /* R_M32R_NONE.  */
11670     case EM_TI_C6000:/* R_C6000_NONE.  */
11671     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11672     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11673     case EM_XC16X:
11674     case EM_C166:    /* R_XC16X_NONE.  */
11675     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11676     case EM_NIOS32:  /* R_NIOS_NONE.  */
11677     case EM_OR1K:    /* R_OR1K_NONE. */
11678       return reloc_type == 0;
11679     case EM_AARCH64:
11680       return reloc_type == 0 || reloc_type == 256;
11681     case EM_NDS32:
11682       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11683               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11684               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11685               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11686               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11687     case EM_XTENSA_OLD:
11688     case EM_XTENSA:
11689       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11690               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11691               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11692               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11693     case EM_METAG:
11694       return reloc_type == 3; /* R_METAG_NONE.  */
11695     }
11696   return FALSE;
11697 }
11698
11699 /* Apply relocations to a section.
11700    Note: So far support has been added only for those relocations
11701    which can be found in debug sections.
11702    FIXME: Add support for more relocations ?  */
11703
11704 static void
11705 apply_relocations (void * file,
11706                    const Elf_Internal_Shdr * section,
11707                    unsigned char * start, bfd_size_type size)
11708 {
11709   Elf_Internal_Shdr * relsec;
11710   unsigned char * end = start + size;
11711
11712   if (elf_header.e_type != ET_REL)
11713     return;
11714
11715   /* Find the reloc section associated with the section.  */
11716   for (relsec = section_headers;
11717        relsec < section_headers + elf_header.e_shnum;
11718        ++relsec)
11719     {
11720       bfd_boolean is_rela;
11721       unsigned long num_relocs;
11722       Elf_Internal_Rela * relocs;
11723       Elf_Internal_Rela * rp;
11724       Elf_Internal_Shdr * symsec;
11725       Elf_Internal_Sym * symtab;
11726       unsigned long num_syms;
11727       Elf_Internal_Sym * sym;
11728
11729       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11730           || relsec->sh_info >= elf_header.e_shnum
11731           || section_headers + relsec->sh_info != section
11732           || relsec->sh_size == 0
11733           || relsec->sh_link >= elf_header.e_shnum)
11734         continue;
11735
11736       is_rela = relsec->sh_type == SHT_RELA;
11737
11738       if (is_rela)
11739         {
11740           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11741                                   relsec->sh_size, & relocs, & num_relocs))
11742             return;
11743         }
11744       else
11745         {
11746           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11747                                  relsec->sh_size, & relocs, & num_relocs))
11748             return;
11749         }
11750
11751       /* SH uses RELA but uses in place value instead of the addend field.  */
11752       if (elf_header.e_machine == EM_SH)
11753         is_rela = FALSE;
11754
11755       symsec = section_headers + relsec->sh_link;
11756       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11757
11758       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11759         {
11760           bfd_vma         addend;
11761           unsigned int    reloc_type;
11762           unsigned int    reloc_size;
11763           unsigned char * rloc;
11764           unsigned long   sym_index;
11765
11766           reloc_type = get_reloc_type (rp->r_info);
11767
11768           if (target_specific_reloc_handling (rp, start, symtab))
11769             continue;
11770           else if (is_none_reloc (reloc_type))
11771             continue;
11772           else if (is_32bit_abs_reloc (reloc_type)
11773                    || is_32bit_pcrel_reloc (reloc_type))
11774             reloc_size = 4;
11775           else if (is_64bit_abs_reloc (reloc_type)
11776                    || is_64bit_pcrel_reloc (reloc_type))
11777             reloc_size = 8;
11778           else if (is_24bit_abs_reloc (reloc_type))
11779             reloc_size = 3;
11780           else if (is_16bit_abs_reloc (reloc_type))
11781             reloc_size = 2;
11782           else
11783             {
11784               static unsigned int prev_reloc = 0;
11785               if (reloc_type != prev_reloc)
11786                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11787                       reloc_type, printable_section_name (section));
11788               prev_reloc = reloc_type;
11789               continue;
11790             }
11791
11792           rloc = start + rp->r_offset;
11793           if ((rloc + reloc_size) > end || (rloc < start))
11794             {
11795               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11796                     (unsigned long) rp->r_offset,
11797                     printable_section_name (section));
11798               continue;
11799             }
11800
11801           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11802           if (sym_index >= num_syms)
11803             {
11804               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11805                     sym_index, printable_section_name (section));
11806               continue;
11807             }
11808           sym = symtab + sym_index;
11809
11810           /* If the reloc has a symbol associated with it,
11811              make sure that it is of an appropriate type.
11812
11813              Relocations against symbols without type can happen.
11814              Gcc -feliminate-dwarf2-dups may generate symbols
11815              without type for debug info.
11816
11817              Icc generates relocations against function symbols
11818              instead of local labels.
11819
11820              Relocations against object symbols can happen, eg when
11821              referencing a global array.  For an example of this see
11822              the _clz.o binary in libgcc.a.  */
11823           if (sym != symtab
11824               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11825             {
11826               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11827                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11828                     (long int)(rp - relocs),
11829                     printable_section_name (relsec));
11830               continue;
11831             }
11832
11833           addend = 0;
11834           if (is_rela)
11835             addend += rp->r_addend;
11836           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11837              partial_inplace.  */
11838           if (!is_rela
11839               || (elf_header.e_machine == EM_XTENSA
11840                   && reloc_type == 1)
11841               || ((elf_header.e_machine == EM_PJ
11842                    || elf_header.e_machine == EM_PJ_OLD)
11843                   && reloc_type == 1)
11844               || ((elf_header.e_machine == EM_D30V
11845                    || elf_header.e_machine == EM_CYGNUS_D30V)
11846                   && reloc_type == 12))
11847             addend += byte_get (rloc, reloc_size);
11848
11849           if (is_32bit_pcrel_reloc (reloc_type)
11850               || is_64bit_pcrel_reloc (reloc_type))
11851             {
11852               /* On HPPA, all pc-relative relocations are biased by 8.  */
11853               if (elf_header.e_machine == EM_PARISC)
11854                 addend -= 8;
11855               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11856                         reloc_size);
11857             }
11858           else
11859             byte_put (rloc, addend + sym->st_value, reloc_size);
11860         }
11861
11862       free (symtab);
11863       free (relocs);
11864       break;
11865     }
11866 }
11867
11868 #ifdef SUPPORT_DISASSEMBLY
11869 static int
11870 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11871 {
11872   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11873
11874   /* FIXME: XXX -- to be done --- XXX */
11875
11876   return 1;
11877 }
11878 #endif
11879
11880 /* Reads in the contents of SECTION from FILE, returning a pointer
11881    to a malloc'ed buffer or NULL if something went wrong.  */
11882
11883 static char *
11884 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11885 {
11886   bfd_size_type num_bytes;
11887
11888   num_bytes = section->sh_size;
11889
11890   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11891     {
11892       printf (_("\nSection '%s' has no data to dump.\n"),
11893               printable_section_name (section));
11894       return NULL;
11895     }
11896
11897   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11898                              _("section contents"));
11899 }
11900
11901
11902 static void
11903 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11904 {
11905   Elf_Internal_Shdr * relsec;
11906   bfd_size_type num_bytes;
11907   char * data;
11908   char * end;
11909   char * start;
11910   bfd_boolean some_strings_shown;
11911
11912   start = get_section_contents (section, file);
11913   if (start == NULL)
11914     return;
11915
11916   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11917
11918   /* If the section being dumped has relocations against it the user might
11919      be expecting these relocations to have been applied.  Check for this
11920      case and issue a warning message in order to avoid confusion.
11921      FIXME: Maybe we ought to have an option that dumps a section with
11922      relocs applied ?  */
11923   for (relsec = section_headers;
11924        relsec < section_headers + elf_header.e_shnum;
11925        ++relsec)
11926     {
11927       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11928           || relsec->sh_info >= elf_header.e_shnum
11929           || section_headers + relsec->sh_info != section
11930           || relsec->sh_size == 0
11931           || relsec->sh_link >= elf_header.e_shnum)
11932         continue;
11933
11934       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11935       break;
11936     }
11937
11938   num_bytes = section->sh_size;
11939   data = start;
11940   end  = start + num_bytes;
11941   some_strings_shown = FALSE;
11942
11943   while (data < end)
11944     {
11945       while (!ISPRINT (* data))
11946         if (++ data >= end)
11947           break;
11948
11949       if (data < end)
11950         {
11951           size_t maxlen = end - data;
11952
11953 #ifndef __MSVCRT__
11954           /* PR 11128: Use two separate invocations in order to work
11955              around bugs in the Solaris 8 implementation of printf.  */
11956           printf ("  [%6tx]  ", data - start);
11957 #else
11958           printf ("  [%6Ix]  ", (size_t) (data - start));
11959 #endif
11960           if (maxlen > 0)
11961             {
11962               print_symbol ((int) maxlen, data);
11963               putchar ('\n');
11964               data += strnlen (data, maxlen);
11965             }
11966           else
11967             {
11968               printf (_("<corrupt>\n"));
11969               data = end;
11970             }
11971           some_strings_shown = TRUE;
11972         }
11973     }
11974
11975   if (! some_strings_shown)
11976     printf (_("  No strings found in this section."));
11977
11978   free (start);
11979
11980   putchar ('\n');
11981 }
11982
11983 static void
11984 dump_section_as_bytes (Elf_Internal_Shdr * section,
11985                        FILE * file,
11986                        bfd_boolean relocate)
11987 {
11988   Elf_Internal_Shdr * relsec;
11989   bfd_size_type bytes;
11990   bfd_vma addr;
11991   unsigned char * data;
11992   unsigned char * start;
11993
11994   start = (unsigned char *) get_section_contents (section, file);
11995   if (start == NULL)
11996     return;
11997
11998   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11999
12000   if (relocate)
12001     {
12002       apply_relocations (file, section, start, section->sh_size);
12003     }
12004   else
12005     {
12006       /* If the section being dumped has relocations against it the user might
12007          be expecting these relocations to have been applied.  Check for this
12008          case and issue a warning message in order to avoid confusion.
12009          FIXME: Maybe we ought to have an option that dumps a section with
12010          relocs applied ?  */
12011       for (relsec = section_headers;
12012            relsec < section_headers + elf_header.e_shnum;
12013            ++relsec)
12014         {
12015           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12016               || relsec->sh_info >= elf_header.e_shnum
12017               || section_headers + relsec->sh_info != section
12018               || relsec->sh_size == 0
12019               || relsec->sh_link >= elf_header.e_shnum)
12020             continue;
12021
12022           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12023           break;
12024         }
12025     }
12026
12027   addr = section->sh_addr;
12028   bytes = section->sh_size;
12029   data = start;
12030
12031   while (bytes)
12032     {
12033       int j;
12034       int k;
12035       int lbytes;
12036
12037       lbytes = (bytes > 16 ? 16 : bytes);
12038
12039       printf ("  0x%8.8lx ", (unsigned long) addr);
12040
12041       for (j = 0; j < 16; j++)
12042         {
12043           if (j < lbytes)
12044             printf ("%2.2x", data[j]);
12045           else
12046             printf ("  ");
12047
12048           if ((j & 3) == 3)
12049             printf (" ");
12050         }
12051
12052       for (j = 0; j < lbytes; j++)
12053         {
12054           k = data[j];
12055           if (k >= ' ' && k < 0x7f)
12056             printf ("%c", k);
12057           else
12058             printf (".");
12059         }
12060
12061       putchar ('\n');
12062
12063       data  += lbytes;
12064       addr  += lbytes;
12065       bytes -= lbytes;
12066     }
12067
12068   free (start);
12069
12070   putchar ('\n');
12071 }
12072
12073 /* Uncompresses a section that was compressed using zlib, in place.  */
12074
12075 static int
12076 uncompress_section_contents (unsigned char **buffer,
12077                              dwarf_size_type *size)
12078 {
12079   dwarf_size_type compressed_size = *size;
12080   unsigned char * compressed_buffer = *buffer;
12081   dwarf_size_type uncompressed_size;
12082   unsigned char * uncompressed_buffer;
12083   z_stream strm;
12084   int rc;
12085   dwarf_size_type header_size = 12;
12086
12087   /* Read the zlib header.  In this case, it should be "ZLIB" followed
12088      by the uncompressed section size, 8 bytes in big-endian order.  */
12089   if (compressed_size < header_size
12090       || ! streq ((char *) compressed_buffer, "ZLIB"))
12091     return 0;
12092
12093   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
12094   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
12095   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
12096   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
12097   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
12098   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
12099   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
12100   uncompressed_size += compressed_buffer[11];
12101
12102   /* It is possible the section consists of several compressed
12103      buffers concatenated together, so we uncompress in a loop.  */
12104   /* PR 18313: The state field in the z_stream structure is supposed
12105      to be invisible to the user (ie us), but some compilers will
12106      still complain about it being used without initialisation.  So
12107      we first zero the entire z_stream structure and then set the fields
12108      that we need.  */
12109   memset (& strm, 0, sizeof strm);
12110   strm.avail_in = compressed_size - header_size;
12111   strm.next_in = (Bytef *) compressed_buffer + header_size;
12112   strm.avail_out = uncompressed_size;
12113   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12114
12115   rc = inflateInit (& strm);
12116   while (strm.avail_in > 0)
12117     {
12118       if (rc != Z_OK)
12119         goto fail;
12120       strm.next_out = ((Bytef *) uncompressed_buffer
12121                        + (uncompressed_size - strm.avail_out));
12122       rc = inflate (&strm, Z_FINISH);
12123       if (rc != Z_STREAM_END)
12124         goto fail;
12125       rc = inflateReset (& strm);
12126     }
12127   rc = inflateEnd (& strm);
12128   if (rc != Z_OK
12129       || strm.avail_out != 0)
12130     goto fail;
12131
12132   *buffer = uncompressed_buffer;
12133   *size = uncompressed_size;
12134   return 1;
12135
12136  fail:
12137   free (uncompressed_buffer);
12138   /* Indicate decompression failure.  */
12139   *buffer = NULL;
12140   return 0;
12141 }
12142
12143 static int
12144 load_specific_debug_section (enum dwarf_section_display_enum debug,
12145                              const Elf_Internal_Shdr * sec, void * file)
12146 {
12147   struct dwarf_section * section = &debug_displays [debug].section;
12148   char buf [64];
12149
12150   /* If it is already loaded, do nothing.  */
12151   if (section->start != NULL)
12152     return 1;
12153
12154   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12155   section->address = sec->sh_addr;
12156   section->user_data = NULL;
12157   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12158                                                sec->sh_offset, 1,
12159                                                sec->sh_size, buf);
12160   if (section->start == NULL)
12161     section->size = 0;
12162   else
12163     {
12164       unsigned char *start = section->start;
12165       dwarf_size_type size = sec->sh_size;
12166
12167       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12168         {
12169           Elf_Internal_Chdr chdr;
12170           unsigned int compression_header_size
12171             = get_compression_header (&chdr, start);
12172           if (chdr.ch_type != ELFCOMPRESS_ZLIB
12173               || chdr.ch_addralign != sec->sh_addralign)
12174             return 0;
12175           start += compression_header_size;
12176           size -= compression_header_size;
12177         }
12178
12179       if (uncompress_section_contents (&start, &size))
12180         {
12181           /* Free the compressed buffer, update the section buffer
12182              and the section size if uncompress is successful.  */
12183           free (section->start);
12184           section->start = start;
12185         }
12186       section->size = size;
12187     }
12188
12189   if (section->start == NULL)
12190     return 0;
12191
12192   if (debug_displays [debug].relocate)
12193     apply_relocations ((FILE *) file, sec, section->start, section->size);
12194
12195   return 1;
12196 }
12197
12198 /* If this is not NULL, load_debug_section will only look for sections
12199    within the list of sections given here.  */
12200 unsigned int *section_subset = NULL;
12201
12202 int
12203 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12204 {
12205   struct dwarf_section * section = &debug_displays [debug].section;
12206   Elf_Internal_Shdr * sec;
12207
12208   /* Locate the debug section.  */
12209   sec = find_section_in_set (section->uncompressed_name, section_subset);
12210   if (sec != NULL)
12211     section->name = section->uncompressed_name;
12212   else
12213     {
12214       sec = find_section_in_set (section->compressed_name, section_subset);
12215       if (sec != NULL)
12216         section->name = section->compressed_name;
12217     }
12218   if (sec == NULL)
12219     return 0;
12220
12221   /* If we're loading from a subset of sections, and we've loaded
12222      a section matching this name before, it's likely that it's a
12223      different one.  */
12224   if (section_subset != NULL)
12225     free_debug_section (debug);
12226
12227   return load_specific_debug_section (debug, sec, (FILE *) file);
12228 }
12229
12230 void
12231 free_debug_section (enum dwarf_section_display_enum debug)
12232 {
12233   struct dwarf_section * section = &debug_displays [debug].section;
12234
12235   if (section->start == NULL)
12236     return;
12237
12238   free ((char *) section->start);
12239   section->start = NULL;
12240   section->address = 0;
12241   section->size = 0;
12242 }
12243
12244 static int
12245 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12246 {
12247   char * name = SECTION_NAME (section);
12248   const char * print_name = printable_section_name (section);
12249   bfd_size_type length;
12250   int result = 1;
12251   int i;
12252
12253   length = section->sh_size;
12254   if (length == 0)
12255     {
12256       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12257       return 0;
12258     }
12259   if (section->sh_type == SHT_NOBITS)
12260     {
12261       /* There is no point in dumping the contents of a debugging section
12262          which has the NOBITS type - the bits in the file will be random.
12263          This can happen when a file containing a .eh_frame section is
12264          stripped with the --only-keep-debug command line option.  */
12265       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12266               print_name);
12267       return 0;
12268     }
12269
12270   if (const_strneq (name, ".gnu.linkonce.wi."))
12271     name = ".debug_info";
12272
12273   /* See if we know how to display the contents of this section.  */
12274   for (i = 0; i < max; i++)
12275     if (streq (debug_displays[i].section.uncompressed_name, name)
12276         || (i == line && const_strneq (name, ".debug_line."))
12277         || streq (debug_displays[i].section.compressed_name, name))
12278       {
12279         struct dwarf_section * sec = &debug_displays [i].section;
12280         int secondary = (section != find_section (name));
12281
12282         if (secondary)
12283           free_debug_section ((enum dwarf_section_display_enum) i);
12284
12285         if (i == line && const_strneq (name, ".debug_line."))
12286           sec->name = name;
12287         else if (streq (sec->uncompressed_name, name))
12288           sec->name = sec->uncompressed_name;
12289         else
12290           sec->name = sec->compressed_name;
12291         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12292                                          section, file))
12293           {
12294             /* If this debug section is part of a CU/TU set in a .dwp file,
12295                restrict load_debug_section to the sections in that set.  */
12296             section_subset = find_cu_tu_set (file, shndx);
12297
12298             result &= debug_displays[i].display (sec, file);
12299
12300             section_subset = NULL;
12301
12302             if (secondary || (i != info && i != abbrev))
12303               free_debug_section ((enum dwarf_section_display_enum) i);
12304           }
12305
12306         break;
12307       }
12308
12309   if (i == max)
12310     {
12311       printf (_("Unrecognized debug section: %s\n"), print_name);
12312       result = 0;
12313     }
12314
12315   return result;
12316 }
12317
12318 /* Set DUMP_SECTS for all sections where dumps were requested
12319    based on section name.  */
12320
12321 static void
12322 initialise_dumps_byname (void)
12323 {
12324   struct dump_list_entry * cur;
12325
12326   for (cur = dump_sects_byname; cur; cur = cur->next)
12327     {
12328       unsigned int i;
12329       int any;
12330
12331       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12332         if (streq (SECTION_NAME (section_headers + i), cur->name))
12333           {
12334             request_dump_bynumber (i, cur->type);
12335             any = 1;
12336           }
12337
12338       if (!any)
12339         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12340               cur->name);
12341     }
12342 }
12343
12344 static void
12345 process_section_contents (FILE * file)
12346 {
12347   Elf_Internal_Shdr * section;
12348   unsigned int i;
12349
12350   if (! do_dump)
12351     return;
12352
12353   initialise_dumps_byname ();
12354
12355   for (i = 0, section = section_headers;
12356        i < elf_header.e_shnum && i < num_dump_sects;
12357        i++, section++)
12358     {
12359 #ifdef SUPPORT_DISASSEMBLY
12360       if (dump_sects[i] & DISASS_DUMP)
12361         disassemble_section (section, file);
12362 #endif
12363       if (dump_sects[i] & HEX_DUMP)
12364         dump_section_as_bytes (section, file, FALSE);
12365
12366       if (dump_sects[i] & RELOC_DUMP)
12367         dump_section_as_bytes (section, file, TRUE);
12368
12369       if (dump_sects[i] & STRING_DUMP)
12370         dump_section_as_strings (section, file);
12371
12372       if (dump_sects[i] & DEBUG_DUMP)
12373         display_debug_section (i, section, file);
12374     }
12375
12376   /* Check to see if the user requested a
12377      dump of a section that does not exist.  */
12378   while (i++ < num_dump_sects)
12379     if (dump_sects[i])
12380       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12381 }
12382
12383 static void
12384 process_mips_fpe_exception (int mask)
12385 {
12386   if (mask)
12387     {
12388       int first = 1;
12389       if (mask & OEX_FPU_INEX)
12390         fputs ("INEX", stdout), first = 0;
12391       if (mask & OEX_FPU_UFLO)
12392         printf ("%sUFLO", first ? "" : "|"), first = 0;
12393       if (mask & OEX_FPU_OFLO)
12394         printf ("%sOFLO", first ? "" : "|"), first = 0;
12395       if (mask & OEX_FPU_DIV0)
12396         printf ("%sDIV0", first ? "" : "|"), first = 0;
12397       if (mask & OEX_FPU_INVAL)
12398         printf ("%sINVAL", first ? "" : "|");
12399     }
12400   else
12401     fputs ("0", stdout);
12402 }
12403
12404 /* Display's the value of TAG at location P.  If TAG is
12405    greater than 0 it is assumed to be an unknown tag, and
12406    a message is printed to this effect.  Otherwise it is
12407    assumed that a message has already been printed.
12408
12409    If the bottom bit of TAG is set it assumed to have a
12410    string value, otherwise it is assumed to have an integer
12411    value.
12412
12413    Returns an updated P pointing to the first unread byte
12414    beyond the end of TAG's value.
12415
12416    Reads at or beyond END will not be made.  */
12417
12418 static unsigned char *
12419 display_tag_value (int tag,
12420                    unsigned char * p,
12421                    const unsigned char * const end)
12422 {
12423   unsigned long val;
12424
12425   if (tag > 0)
12426     printf ("  Tag_unknown_%d: ", tag);
12427
12428   if (p >= end)
12429     {
12430       warn (_("<corrupt tag>\n"));
12431     }
12432   else if (tag & 1)
12433     {
12434       /* PR 17531 file: 027-19978-0.004.  */
12435       size_t maxlen = (end - p) - 1;
12436
12437       putchar ('"');
12438       if (maxlen > 0)
12439         {
12440           print_symbol ((int) maxlen, (const char *) p);
12441           p += strnlen ((char *) p, maxlen) + 1;
12442         }
12443       else
12444         {
12445           printf (_("<corrupt string tag>"));
12446           p = (unsigned char *) end;
12447         }
12448       printf ("\"\n");
12449     }
12450   else
12451     {
12452       unsigned int len;
12453
12454       val = read_uleb128 (p, &len, end);
12455       p += len;
12456       printf ("%ld (0x%lx)\n", val, val);
12457     }
12458
12459   assert (p <= end);
12460   return p;
12461 }
12462
12463 /* ARM EABI attributes section.  */
12464 typedef struct
12465 {
12466   unsigned int tag;
12467   const char * name;
12468   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12469   unsigned int type;
12470   const char ** table;
12471 } arm_attr_public_tag;
12472
12473 static const char * arm_attr_tag_CPU_arch[] =
12474   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12475    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12476 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12477 static const char * arm_attr_tag_THUMB_ISA_use[] =
12478   {"No", "Thumb-1", "Thumb-2"};
12479 static const char * arm_attr_tag_FP_arch[] =
12480   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12481    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12482 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12483 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12484   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12485 static const char * arm_attr_tag_PCS_config[] =
12486   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12487    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12488 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12489   {"V6", "SB", "TLS", "Unused"};
12490 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12491   {"Absolute", "PC-relative", "SB-relative", "None"};
12492 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12493   {"Absolute", "PC-relative", "None"};
12494 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12495   {"None", "direct", "GOT-indirect"};
12496 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12497   {"None", "??? 1", "2", "??? 3", "4"};
12498 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12499 static const char * arm_attr_tag_ABI_FP_denormal[] =
12500   {"Unused", "Needed", "Sign only"};
12501 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12502 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12503 static const char * arm_attr_tag_ABI_FP_number_model[] =
12504   {"Unused", "Finite", "RTABI", "IEEE 754"};
12505 static const char * arm_attr_tag_ABI_enum_size[] =
12506   {"Unused", "small", "int", "forced to int"};
12507 static const char * arm_attr_tag_ABI_HardFP_use[] =
12508   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12509 static const char * arm_attr_tag_ABI_VFP_args[] =
12510   {"AAPCS", "VFP registers", "custom", "compatible"};
12511 static const char * arm_attr_tag_ABI_WMMX_args[] =
12512   {"AAPCS", "WMMX registers", "custom"};
12513 static const char * arm_attr_tag_ABI_optimization_goals[] =
12514   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12515     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12516 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12517   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12518     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12519 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12520 static const char * arm_attr_tag_FP_HP_extension[] =
12521   {"Not Allowed", "Allowed"};
12522 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12523   {"None", "IEEE 754", "Alternative Format"};
12524 static const char * arm_attr_tag_MPextension_use[] =
12525   {"Not Allowed", "Allowed"};
12526 static const char * arm_attr_tag_DIV_use[] =
12527   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12528     "Allowed in v7-A with integer division extension"};
12529 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12530 static const char * arm_attr_tag_Virtualization_use[] =
12531   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12532     "TrustZone and Virtualization Extensions"};
12533 static const char * arm_attr_tag_MPextension_use_legacy[] =
12534   {"Not Allowed", "Allowed"};
12535
12536 #define LOOKUP(id, name) \
12537   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12538 static arm_attr_public_tag arm_attr_public_tags[] =
12539 {
12540   {4, "CPU_raw_name", 1, NULL},
12541   {5, "CPU_name", 1, NULL},
12542   LOOKUP(6, CPU_arch),
12543   {7, "CPU_arch_profile", 0, NULL},
12544   LOOKUP(8, ARM_ISA_use),
12545   LOOKUP(9, THUMB_ISA_use),
12546   LOOKUP(10, FP_arch),
12547   LOOKUP(11, WMMX_arch),
12548   LOOKUP(12, Advanced_SIMD_arch),
12549   LOOKUP(13, PCS_config),
12550   LOOKUP(14, ABI_PCS_R9_use),
12551   LOOKUP(15, ABI_PCS_RW_data),
12552   LOOKUP(16, ABI_PCS_RO_data),
12553   LOOKUP(17, ABI_PCS_GOT_use),
12554   LOOKUP(18, ABI_PCS_wchar_t),
12555   LOOKUP(19, ABI_FP_rounding),
12556   LOOKUP(20, ABI_FP_denormal),
12557   LOOKUP(21, ABI_FP_exceptions),
12558   LOOKUP(22, ABI_FP_user_exceptions),
12559   LOOKUP(23, ABI_FP_number_model),
12560   {24, "ABI_align_needed", 0, NULL},
12561   {25, "ABI_align_preserved", 0, NULL},
12562   LOOKUP(26, ABI_enum_size),
12563   LOOKUP(27, ABI_HardFP_use),
12564   LOOKUP(28, ABI_VFP_args),
12565   LOOKUP(29, ABI_WMMX_args),
12566   LOOKUP(30, ABI_optimization_goals),
12567   LOOKUP(31, ABI_FP_optimization_goals),
12568   {32, "compatibility", 0, NULL},
12569   LOOKUP(34, CPU_unaligned_access),
12570   LOOKUP(36, FP_HP_extension),
12571   LOOKUP(38, ABI_FP_16bit_format),
12572   LOOKUP(42, MPextension_use),
12573   LOOKUP(44, DIV_use),
12574   {64, "nodefaults", 0, NULL},
12575   {65, "also_compatible_with", 0, NULL},
12576   LOOKUP(66, T2EE_use),
12577   {67, "conformance", 1, NULL},
12578   LOOKUP(68, Virtualization_use),
12579   LOOKUP(70, MPextension_use_legacy)
12580 };
12581 #undef LOOKUP
12582
12583 static unsigned char *
12584 display_arm_attribute (unsigned char * p,
12585                        const unsigned char * const end)
12586 {
12587   unsigned int tag;
12588   unsigned int len;
12589   unsigned int val;
12590   arm_attr_public_tag * attr;
12591   unsigned i;
12592   unsigned int type;
12593
12594   tag = read_uleb128 (p, &len, end);
12595   p += len;
12596   attr = NULL;
12597   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12598     {
12599       if (arm_attr_public_tags[i].tag == tag)
12600         {
12601           attr = &arm_attr_public_tags[i];
12602           break;
12603         }
12604     }
12605
12606   if (attr)
12607     {
12608       printf ("  Tag_%s: ", attr->name);
12609       switch (attr->type)
12610         {
12611         case 0:
12612           switch (tag)
12613             {
12614             case 7: /* Tag_CPU_arch_profile.  */
12615               val = read_uleb128 (p, &len, end);
12616               p += len;
12617               switch (val)
12618                 {
12619                 case 0: printf (_("None\n")); break;
12620                 case 'A': printf (_("Application\n")); break;
12621                 case 'R': printf (_("Realtime\n")); break;
12622                 case 'M': printf (_("Microcontroller\n")); break;
12623                 case 'S': printf (_("Application or Realtime\n")); break;
12624                 default: printf ("??? (%d)\n", val); break;
12625                 }
12626               break;
12627
12628             case 24: /* Tag_align_needed.  */
12629               val = read_uleb128 (p, &len, end);
12630               p += len;
12631               switch (val)
12632                 {
12633                 case 0: printf (_("None\n")); break;
12634                 case 1: printf (_("8-byte\n")); break;
12635                 case 2: printf (_("4-byte\n")); break;
12636                 case 3: printf ("??? 3\n"); break;
12637                 default:
12638                   if (val <= 12)
12639                     printf (_("8-byte and up to %d-byte extended\n"),
12640                             1 << val);
12641                   else
12642                     printf ("??? (%d)\n", val);
12643                   break;
12644                 }
12645               break;
12646
12647             case 25: /* Tag_align_preserved.  */
12648               val = read_uleb128 (p, &len, end);
12649               p += len;
12650               switch (val)
12651                 {
12652                 case 0: printf (_("None\n")); break;
12653                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12654                 case 2: printf (_("8-byte\n")); break;
12655                 case 3: printf ("??? 3\n"); break;
12656                 default:
12657                   if (val <= 12)
12658                     printf (_("8-byte and up to %d-byte extended\n"),
12659                             1 << val);
12660                   else
12661                     printf ("??? (%d)\n", val);
12662                   break;
12663                 }
12664               break;
12665
12666             case 32: /* Tag_compatibility.  */
12667               {
12668                 val = read_uleb128 (p, &len, end);
12669                 p += len;
12670                 printf (_("flag = %d, vendor = "), val);
12671                 if (p < end - 1)
12672                   {
12673                     size_t maxlen = (end - p) - 1;
12674
12675                     print_symbol ((int) maxlen, (const char *) p);
12676                     p += strnlen ((char *) p, maxlen) + 1;
12677                   }
12678                 else
12679                   {
12680                     printf (_("<corrupt>"));
12681                     p = (unsigned char *) end;
12682                   }
12683                 putchar ('\n');
12684               }
12685               break;
12686
12687             case 64: /* Tag_nodefaults.  */
12688               /* PR 17531: file: 001-505008-0.01.  */
12689               if (p < end)
12690                 p++;
12691               printf (_("True\n"));
12692               break;
12693
12694             case 65: /* Tag_also_compatible_with.  */
12695               val = read_uleb128 (p, &len, end);
12696               p += len;
12697               if (val == 6 /* Tag_CPU_arch.  */)
12698                 {
12699                   val = read_uleb128 (p, &len, end);
12700                   p += len;
12701                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12702                     printf ("??? (%d)\n", val);
12703                   else
12704                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12705                 }
12706               else
12707                 printf ("???\n");
12708               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12709                 ;
12710               break;
12711
12712             default:
12713               printf (_("<unknown: %d>\n"), tag);
12714               break;
12715             }
12716           return p;
12717
12718         case 1:
12719           return display_tag_value (-1, p, end);
12720         case 2:
12721           return display_tag_value (0, p, end);
12722
12723         default:
12724           assert (attr->type & 0x80);
12725           val = read_uleb128 (p, &len, end);
12726           p += len;
12727           type = attr->type & 0x7f;
12728           if (val >= type)
12729             printf ("??? (%d)\n", val);
12730           else
12731             printf ("%s\n", attr->table[val]);
12732           return p;
12733         }
12734     }
12735
12736   return display_tag_value (tag, p, end);
12737 }
12738
12739 static unsigned char *
12740 display_gnu_attribute (unsigned char * p,
12741                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12742                        const unsigned char * const end)
12743 {
12744   int tag;
12745   unsigned int len;
12746   int val;
12747
12748   tag = read_uleb128 (p, &len, end);
12749   p += len;
12750
12751   /* Tag_compatibility is the only generic GNU attribute defined at
12752      present.  */
12753   if (tag == 32)
12754     {
12755       val = read_uleb128 (p, &len, end);
12756       p += len;
12757
12758       printf (_("flag = %d, vendor = "), val);
12759       if (p == end)
12760         {
12761           printf (_("<corrupt>\n"));
12762           warn (_("corrupt vendor attribute\n"));
12763         }
12764       else
12765         {
12766           if (p < end - 1)
12767             {
12768               size_t maxlen = (end - p) - 1;
12769
12770               print_symbol ((int) maxlen, (const char *) p);
12771               p += strnlen ((char *) p, maxlen) + 1;
12772             }
12773           else
12774             {
12775               printf (_("<corrupt>"));
12776               p = (unsigned char *) end;
12777             }
12778           putchar ('\n');
12779         }
12780       return p;
12781     }
12782
12783   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12784     return display_proc_gnu_attribute (p, tag, end);
12785
12786   return display_tag_value (tag, p, end);
12787 }
12788
12789 static unsigned char *
12790 display_power_gnu_attribute (unsigned char * p,
12791                              int tag,
12792                              const unsigned char * const end)
12793 {
12794   unsigned int len;
12795   int val;
12796
12797   if (tag == Tag_GNU_Power_ABI_FP)
12798     {
12799       val = read_uleb128 (p, &len, end);
12800       p += len;
12801       printf ("  Tag_GNU_Power_ABI_FP: ");
12802
12803       switch (val)
12804         {
12805         case 0:
12806           printf (_("Hard or soft float\n"));
12807           break;
12808         case 1:
12809           printf (_("Hard float\n"));
12810           break;
12811         case 2:
12812           printf (_("Soft float\n"));
12813           break;
12814         case 3:
12815           printf (_("Single-precision hard float\n"));
12816           break;
12817         default:
12818           printf ("??? (%d)\n", val);
12819           break;
12820         }
12821       return p;
12822    }
12823
12824   if (tag == Tag_GNU_Power_ABI_Vector)
12825     {
12826       val = read_uleb128 (p, &len, end);
12827       p += len;
12828       printf ("  Tag_GNU_Power_ABI_Vector: ");
12829       switch (val)
12830         {
12831         case 0:
12832           printf (_("Any\n"));
12833           break;
12834         case 1:
12835           printf (_("Generic\n"));
12836           break;
12837         case 2:
12838           printf ("AltiVec\n");
12839           break;
12840         case 3:
12841           printf ("SPE\n");
12842           break;
12843         default:
12844           printf ("??? (%d)\n", val);
12845           break;
12846         }
12847       return p;
12848    }
12849
12850   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12851     {
12852       if (p == end)
12853         {
12854           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12855           return p;
12856         }
12857
12858       val = read_uleb128 (p, &len, end);
12859       p += len;
12860       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12861       switch (val)
12862        {
12863        case 0:
12864          printf (_("Any\n"));
12865          break;
12866        case 1:
12867          printf ("r3/r4\n");
12868          break;
12869        case 2:
12870          printf (_("Memory\n"));
12871          break;
12872        default:
12873          printf ("??? (%d)\n", val);
12874          break;
12875        }
12876       return p;
12877     }
12878
12879   return display_tag_value (tag & 1, p, end);
12880 }
12881
12882 static unsigned char *
12883 display_s390_gnu_attribute (unsigned char * p,
12884                             int tag,
12885                             const unsigned char * const end)
12886 {
12887   unsigned int len;
12888   int val;
12889
12890   if (tag == Tag_GNU_S390_ABI_Vector)
12891     {
12892       val = read_uleb128 (p, &len, end);
12893       p += len;
12894       printf ("  Tag_GNU_S390_ABI_Vector: ");
12895
12896       switch (val)
12897         {
12898         case 0:
12899           printf (_("any\n"));
12900           break;
12901         case 1:
12902           printf (_("software\n"));
12903           break;
12904         case 2:
12905           printf (_("hardware\n"));
12906           break;
12907         default:
12908           printf ("??? (%d)\n", val);
12909           break;
12910         }
12911       return p;
12912    }
12913
12914   return display_tag_value (tag & 1, p, end);
12915 }
12916
12917 static void
12918 display_sparc_hwcaps (int mask)
12919 {
12920   if (mask)
12921     {
12922       int first = 1;
12923
12924       if (mask & ELF_SPARC_HWCAP_MUL32)
12925         fputs ("mul32", stdout), first = 0;
12926       if (mask & ELF_SPARC_HWCAP_DIV32)
12927         printf ("%sdiv32", first ? "" : "|"), first = 0;
12928       if (mask & ELF_SPARC_HWCAP_FSMULD)
12929         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12930       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12931         printf ("%sv8plus", first ? "" : "|"), first = 0;
12932       if (mask & ELF_SPARC_HWCAP_POPC)
12933         printf ("%spopc", first ? "" : "|"), first = 0;
12934       if (mask & ELF_SPARC_HWCAP_VIS)
12935         printf ("%svis", first ? "" : "|"), first = 0;
12936       if (mask & ELF_SPARC_HWCAP_VIS2)
12937         printf ("%svis2", first ? "" : "|"), first = 0;
12938       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12939         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12940       if (mask & ELF_SPARC_HWCAP_FMAF)
12941         printf ("%sfmaf", first ? "" : "|"), first = 0;
12942       if (mask & ELF_SPARC_HWCAP_VIS3)
12943         printf ("%svis3", first ? "" : "|"), first = 0;
12944       if (mask & ELF_SPARC_HWCAP_HPC)
12945         printf ("%shpc", first ? "" : "|"), first = 0;
12946       if (mask & ELF_SPARC_HWCAP_RANDOM)
12947         printf ("%srandom", first ? "" : "|"), first = 0;
12948       if (mask & ELF_SPARC_HWCAP_TRANS)
12949         printf ("%strans", first ? "" : "|"), first = 0;
12950       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12951         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12952       if (mask & ELF_SPARC_HWCAP_IMA)
12953         printf ("%sima", first ? "" : "|"), first = 0;
12954       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12955         printf ("%scspare", first ? "" : "|"), first = 0;
12956     }
12957   else
12958     fputc ('0', stdout);
12959   fputc ('\n', stdout);
12960 }
12961
12962 static void
12963 display_sparc_hwcaps2 (int mask)
12964 {
12965   if (mask)
12966     {
12967       int first = 1;
12968
12969       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12970         fputs ("fjathplus", stdout), first = 0;
12971       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12972         printf ("%svis3b", first ? "" : "|"), first = 0;
12973       if (mask & ELF_SPARC_HWCAP2_ADP)
12974         printf ("%sadp", first ? "" : "|"), first = 0;
12975       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12976         printf ("%ssparc5", first ? "" : "|"), first = 0;
12977       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12978         printf ("%smwait", first ? "" : "|"), first = 0;
12979       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12980         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12981       if (mask & ELF_SPARC_HWCAP2_XMONT)
12982         printf ("%sxmont2", first ? "" : "|"), first = 0;
12983       if (mask & ELF_SPARC_HWCAP2_NSEC)
12984         printf ("%snsec", first ? "" : "|"), first = 0;
12985       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12986         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12987       if (mask & ELF_SPARC_HWCAP2_FJDES)
12988         printf ("%sfjdes", first ? "" : "|"), first = 0;
12989       if (mask & ELF_SPARC_HWCAP2_FJAES)
12990         printf ("%sfjaes", first ? "" : "|"), first = 0;
12991     }
12992   else
12993     fputc ('0', stdout);
12994   fputc ('\n', stdout);
12995 }
12996
12997 static unsigned char *
12998 display_sparc_gnu_attribute (unsigned char * p,
12999                              int tag,
13000                              const unsigned char * const end)
13001 {
13002   unsigned int len;
13003   int val;
13004
13005   if (tag == Tag_GNU_Sparc_HWCAPS)
13006     {
13007       val = read_uleb128 (p, &len, end);
13008       p += len;
13009       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13010       display_sparc_hwcaps (val);
13011       return p;
13012     }
13013   if (tag == Tag_GNU_Sparc_HWCAPS2)
13014     {
13015       val = read_uleb128 (p, &len, end);
13016       p += len;
13017       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13018       display_sparc_hwcaps2 (val);
13019       return p;
13020     }
13021
13022   return display_tag_value (tag, p, end);
13023 }
13024
13025 static void
13026 print_mips_fp_abi_value (int val)
13027 {
13028   switch (val)
13029     {
13030     case Val_GNU_MIPS_ABI_FP_ANY:
13031       printf (_("Hard or soft float\n"));
13032       break;
13033     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13034       printf (_("Hard float (double precision)\n"));
13035       break;
13036     case Val_GNU_MIPS_ABI_FP_SINGLE:
13037       printf (_("Hard float (single precision)\n"));
13038       break;
13039     case Val_GNU_MIPS_ABI_FP_SOFT:
13040       printf (_("Soft float\n"));
13041       break;
13042     case Val_GNU_MIPS_ABI_FP_OLD_64:
13043       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13044       break;
13045     case Val_GNU_MIPS_ABI_FP_XX:
13046       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13047       break;
13048     case Val_GNU_MIPS_ABI_FP_64:
13049       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13050       break;
13051     case Val_GNU_MIPS_ABI_FP_64A:
13052       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13053       break;
13054     default:
13055       printf ("??? (%d)\n", val);
13056       break;
13057     }
13058 }
13059
13060 static unsigned char *
13061 display_mips_gnu_attribute (unsigned char * p,
13062                             int tag,
13063                             const unsigned char * const end)
13064 {
13065   if (tag == Tag_GNU_MIPS_ABI_FP)
13066     {
13067       unsigned int len;
13068       int val;
13069
13070       val = read_uleb128 (p, &len, end);
13071       p += len;
13072       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13073
13074       print_mips_fp_abi_value (val);
13075
13076       return p;
13077    }
13078
13079   if (tag == Tag_GNU_MIPS_ABI_MSA)
13080     {
13081       unsigned int len;
13082       int val;
13083
13084       val = read_uleb128 (p, &len, end);
13085       p += len;
13086       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13087
13088       switch (val)
13089         {
13090         case Val_GNU_MIPS_ABI_MSA_ANY:
13091           printf (_("Any MSA or not\n"));
13092           break;
13093         case Val_GNU_MIPS_ABI_MSA_128:
13094           printf (_("128-bit MSA\n"));
13095           break;
13096         default:
13097           printf ("??? (%d)\n", val);
13098           break;
13099         }
13100       return p;
13101     }
13102
13103   return display_tag_value (tag & 1, p, end);
13104 }
13105
13106 static unsigned char *
13107 display_tic6x_attribute (unsigned char * p,
13108                          const unsigned char * const end)
13109 {
13110   int tag;
13111   unsigned int len;
13112   int val;
13113
13114   tag = read_uleb128 (p, &len, end);
13115   p += len;
13116
13117   switch (tag)
13118     {
13119     case Tag_ISA:
13120       val = read_uleb128 (p, &len, end);
13121       p += len;
13122       printf ("  Tag_ISA: ");
13123
13124       switch (val)
13125         {
13126         case C6XABI_Tag_ISA_none:
13127           printf (_("None\n"));
13128           break;
13129         case C6XABI_Tag_ISA_C62X:
13130           printf ("C62x\n");
13131           break;
13132         case C6XABI_Tag_ISA_C67X:
13133           printf ("C67x\n");
13134           break;
13135         case C6XABI_Tag_ISA_C67XP:
13136           printf ("C67x+\n");
13137           break;
13138         case C6XABI_Tag_ISA_C64X:
13139           printf ("C64x\n");
13140           break;
13141         case C6XABI_Tag_ISA_C64XP:
13142           printf ("C64x+\n");
13143           break;
13144         case C6XABI_Tag_ISA_C674X:
13145           printf ("C674x\n");
13146           break;
13147         default:
13148           printf ("??? (%d)\n", val);
13149           break;
13150         }
13151       return p;
13152
13153     case Tag_ABI_wchar_t:
13154       val = read_uleb128 (p, &len, end);
13155       p += len;
13156       printf ("  Tag_ABI_wchar_t: ");
13157       switch (val)
13158         {
13159         case 0:
13160           printf (_("Not used\n"));
13161           break;
13162         case 1:
13163           printf (_("2 bytes\n"));
13164           break;
13165         case 2:
13166           printf (_("4 bytes\n"));
13167           break;
13168         default:
13169           printf ("??? (%d)\n", val);
13170           break;
13171         }
13172       return p;
13173
13174     case Tag_ABI_stack_align_needed:
13175       val = read_uleb128 (p, &len, end);
13176       p += len;
13177       printf ("  Tag_ABI_stack_align_needed: ");
13178       switch (val)
13179         {
13180         case 0:
13181           printf (_("8-byte\n"));
13182           break;
13183         case 1:
13184           printf (_("16-byte\n"));
13185           break;
13186         default:
13187           printf ("??? (%d)\n", val);
13188           break;
13189         }
13190       return p;
13191
13192     case Tag_ABI_stack_align_preserved:
13193       val = read_uleb128 (p, &len, end);
13194       p += len;
13195       printf ("  Tag_ABI_stack_align_preserved: ");
13196       switch (val)
13197         {
13198         case 0:
13199           printf (_("8-byte\n"));
13200           break;
13201         case 1:
13202           printf (_("16-byte\n"));
13203           break;
13204         default:
13205           printf ("??? (%d)\n", val);
13206           break;
13207         }
13208       return p;
13209
13210     case Tag_ABI_DSBT:
13211       val = read_uleb128 (p, &len, end);
13212       p += len;
13213       printf ("  Tag_ABI_DSBT: ");
13214       switch (val)
13215         {
13216         case 0:
13217           printf (_("DSBT addressing not used\n"));
13218           break;
13219         case 1:
13220           printf (_("DSBT addressing used\n"));
13221           break;
13222         default:
13223           printf ("??? (%d)\n", val);
13224           break;
13225         }
13226       return p;
13227
13228     case Tag_ABI_PID:
13229       val = read_uleb128 (p, &len, end);
13230       p += len;
13231       printf ("  Tag_ABI_PID: ");
13232       switch (val)
13233         {
13234         case 0:
13235           printf (_("Data addressing position-dependent\n"));
13236           break;
13237         case 1:
13238           printf (_("Data addressing position-independent, GOT near DP\n"));
13239           break;
13240         case 2:
13241           printf (_("Data addressing position-independent, GOT far from DP\n"));
13242           break;
13243         default:
13244           printf ("??? (%d)\n", val);
13245           break;
13246         }
13247       return p;
13248
13249     case Tag_ABI_PIC:
13250       val = read_uleb128 (p, &len, end);
13251       p += len;
13252       printf ("  Tag_ABI_PIC: ");
13253       switch (val)
13254         {
13255         case 0:
13256           printf (_("Code addressing position-dependent\n"));
13257           break;
13258         case 1:
13259           printf (_("Code addressing position-independent\n"));
13260           break;
13261         default:
13262           printf ("??? (%d)\n", val);
13263           break;
13264         }
13265       return p;
13266
13267     case Tag_ABI_array_object_alignment:
13268       val = read_uleb128 (p, &len, end);
13269       p += len;
13270       printf ("  Tag_ABI_array_object_alignment: ");
13271       switch (val)
13272         {
13273         case 0:
13274           printf (_("8-byte\n"));
13275           break;
13276         case 1:
13277           printf (_("4-byte\n"));
13278           break;
13279         case 2:
13280           printf (_("16-byte\n"));
13281           break;
13282         default:
13283           printf ("??? (%d)\n", val);
13284           break;
13285         }
13286       return p;
13287
13288     case Tag_ABI_array_object_align_expected:
13289       val = read_uleb128 (p, &len, end);
13290       p += len;
13291       printf ("  Tag_ABI_array_object_align_expected: ");
13292       switch (val)
13293         {
13294         case 0:
13295           printf (_("8-byte\n"));
13296           break;
13297         case 1:
13298           printf (_("4-byte\n"));
13299           break;
13300         case 2:
13301           printf (_("16-byte\n"));
13302           break;
13303         default:
13304           printf ("??? (%d)\n", val);
13305           break;
13306         }
13307       return p;
13308
13309     case Tag_ABI_compatibility:
13310       {
13311         val = read_uleb128 (p, &len, end);
13312         p += len;
13313         printf ("  Tag_ABI_compatibility: ");
13314         printf (_("flag = %d, vendor = "), val);
13315         if (p < end - 1)
13316           {
13317             size_t maxlen = (end - p) - 1;
13318
13319             print_symbol ((int) maxlen, (const char *) p);
13320             p += strnlen ((char *) p, maxlen) + 1;
13321           }
13322         else
13323           {
13324             printf (_("<corrupt>"));
13325             p = (unsigned char *) end;
13326           }
13327         putchar ('\n');
13328         return p;
13329       }
13330
13331     case Tag_ABI_conformance:
13332       {
13333         printf ("  Tag_ABI_conformance: \"");
13334         if (p < end - 1)
13335           {
13336             size_t maxlen = (end - p) - 1;
13337
13338             print_symbol ((int) maxlen, (const char *) p);
13339             p += strnlen ((char *) p, maxlen) + 1;
13340           }
13341         else
13342           {
13343             printf (_("<corrupt>"));
13344             p = (unsigned char *) end;
13345           }
13346         printf ("\"\n");
13347         return p;
13348       }
13349     }
13350
13351   return display_tag_value (tag, p, end);
13352 }
13353
13354 static void
13355 display_raw_attribute (unsigned char * p, unsigned char * end)
13356 {
13357   unsigned long addr = 0;
13358   size_t bytes = end - p;
13359
13360   assert (end > p);
13361   while (bytes)
13362     {
13363       int j;
13364       int k;
13365       int lbytes = (bytes > 16 ? 16 : bytes);
13366
13367       printf ("  0x%8.8lx ", addr);
13368
13369       for (j = 0; j < 16; j++)
13370         {
13371           if (j < lbytes)
13372             printf ("%2.2x", p[j]);
13373           else
13374             printf ("  ");
13375
13376           if ((j & 3) == 3)
13377             printf (" ");
13378         }
13379
13380       for (j = 0; j < lbytes; j++)
13381         {
13382           k = p[j];
13383           if (k >= ' ' && k < 0x7f)
13384             printf ("%c", k);
13385           else
13386             printf (".");
13387         }
13388
13389       putchar ('\n');
13390
13391       p  += lbytes;
13392       bytes -= lbytes;
13393       addr += lbytes;
13394     }
13395
13396   putchar ('\n');
13397 }
13398
13399 static unsigned char *
13400 display_msp430x_attribute (unsigned char * p,
13401                            const unsigned char * const end)
13402 {
13403   unsigned int len;
13404   int val;
13405   int tag;
13406
13407   tag = read_uleb128 (p, & len, end);
13408   p += len;
13409
13410   switch (tag)
13411     {
13412     case OFBA_MSPABI_Tag_ISA:
13413       val = read_uleb128 (p, &len, end);
13414       p += len;
13415       printf ("  Tag_ISA: ");
13416       switch (val)
13417         {
13418         case 0: printf (_("None\n")); break;
13419         case 1: printf (_("MSP430\n")); break;
13420         case 2: printf (_("MSP430X\n")); break;
13421         default: printf ("??? (%d)\n", val); break;
13422         }
13423       break;
13424
13425     case OFBA_MSPABI_Tag_Code_Model:
13426       val = read_uleb128 (p, &len, end);
13427       p += len;
13428       printf ("  Tag_Code_Model: ");
13429       switch (val)
13430         {
13431         case 0: printf (_("None\n")); break;
13432         case 1: printf (_("Small\n")); break;
13433         case 2: printf (_("Large\n")); break;
13434         default: printf ("??? (%d)\n", val); break;
13435         }
13436       break;
13437
13438     case OFBA_MSPABI_Tag_Data_Model:
13439       val = read_uleb128 (p, &len, end);
13440       p += len;
13441       printf ("  Tag_Data_Model: ");
13442       switch (val)
13443         {
13444         case 0: printf (_("None\n")); break;
13445         case 1: printf (_("Small\n")); break;
13446         case 2: printf (_("Large\n")); break;
13447         case 3: printf (_("Restricted Large\n")); break;
13448         default: printf ("??? (%d)\n", val); break;
13449         }
13450       break;
13451
13452     default:
13453       printf (_("  <unknown tag %d>: "), tag);
13454
13455       if (tag & 1)
13456         {
13457           putchar ('"');
13458           if (p < end - 1)
13459             {
13460               size_t maxlen = (end - p) - 1;
13461
13462               print_symbol ((int) maxlen, (const char *) p);
13463               p += strnlen ((char *) p, maxlen) + 1;
13464             }
13465           else
13466             {
13467               printf (_("<corrupt>"));
13468               p = (unsigned char *) end;
13469             }
13470           printf ("\"\n");
13471         }
13472       else
13473         {
13474           val = read_uleb128 (p, &len, end);
13475           p += len;
13476           printf ("%d (0x%x)\n", val, val);
13477         }
13478       break;
13479    }
13480
13481   assert (p <= end);
13482   return p;
13483 }
13484
13485 static int
13486 process_attributes (FILE * file,
13487                     const char * public_name,
13488                     unsigned int proc_type,
13489                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13490                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13491 {
13492   Elf_Internal_Shdr * sect;
13493   unsigned i;
13494
13495   /* Find the section header so that we get the size.  */
13496   for (i = 0, sect = section_headers;
13497        i < elf_header.e_shnum;
13498        i++, sect++)
13499     {
13500       unsigned char * contents;
13501       unsigned char * p;
13502
13503       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13504         continue;
13505
13506       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13507                                              sect->sh_size, _("attributes"));
13508       if (contents == NULL)
13509         continue;
13510
13511       p = contents;
13512       if (*p == 'A')
13513         {
13514           bfd_vma section_len;
13515
13516           section_len = sect->sh_size - 1;
13517           p++;
13518
13519           while (section_len > 0)
13520             {
13521               bfd_vma attr_len;
13522               unsigned int namelen;
13523               bfd_boolean public_section;
13524               bfd_boolean gnu_section;
13525
13526               if (section_len <= 4)
13527                 {
13528                   error (_("Tag section ends prematurely\n"));
13529                   break;
13530                 }
13531               attr_len = byte_get (p, 4);
13532               p += 4;
13533
13534               if (attr_len > section_len)
13535                 {
13536                   error (_("Bad attribute length (%u > %u)\n"),
13537                           (unsigned) attr_len, (unsigned) section_len);
13538                   attr_len = section_len;
13539                 }
13540               /* PR 17531: file: 001-101425-0.004  */
13541               else if (attr_len < 5)
13542                 {
13543                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13544                   break;
13545                 }
13546
13547               section_len -= attr_len;
13548               attr_len -= 4;
13549
13550               namelen = strnlen ((char *) p, attr_len) + 1;
13551               if (namelen == 0 || namelen >= attr_len)
13552                 {
13553                   error (_("Corrupt attribute section name\n"));
13554                   break;
13555                 }
13556
13557               printf (_("Attribute Section: "));
13558               print_symbol (INT_MAX, (const char *) p);
13559               putchar ('\n');
13560
13561               if (public_name && streq ((char *) p, public_name))
13562                 public_section = TRUE;
13563               else
13564                 public_section = FALSE;
13565
13566               if (streq ((char *) p, "gnu"))
13567                 gnu_section = TRUE;
13568               else
13569                 gnu_section = FALSE;
13570
13571               p += namelen;
13572               attr_len -= namelen;
13573
13574               while (attr_len > 0 && p < contents + sect->sh_size)
13575                 {
13576                   int tag;
13577                   int val;
13578                   bfd_vma size;
13579                   unsigned char * end;
13580
13581                   /* PR binutils/17531: Safe handling of corrupt files.  */
13582                   if (attr_len < 6)
13583                     {
13584                       error (_("Unused bytes at end of section\n"));
13585                       section_len = 0;
13586                       break;
13587                     }
13588
13589                   tag = *(p++);
13590                   size = byte_get (p, 4);
13591                   if (size > attr_len)
13592                     {
13593                       error (_("Bad subsection length (%u > %u)\n"),
13594                               (unsigned) size, (unsigned) attr_len);
13595                       size = attr_len;
13596                     }
13597                   /* PR binutils/17531: Safe handling of corrupt files.  */
13598                   if (size < 6)
13599                     {
13600                       error (_("Bad subsection length (%u < 6)\n"),
13601                               (unsigned) size);
13602                       section_len = 0;
13603                       break;
13604                     }
13605
13606                   attr_len -= size;
13607                   end = p + size - 1;
13608                   assert (end <= contents + sect->sh_size);
13609                   p += 4;
13610
13611                   switch (tag)
13612                     {
13613                     case 1:
13614                       printf (_("File Attributes\n"));
13615                       break;
13616                     case 2:
13617                       printf (_("Section Attributes:"));
13618                       goto do_numlist;
13619                     case 3:
13620                       printf (_("Symbol Attributes:"));
13621                     do_numlist:
13622                       for (;;)
13623                         {
13624                           unsigned int j;
13625
13626                           val = read_uleb128 (p, &j, end);
13627                           p += j;
13628                           if (val == 0)
13629                             break;
13630                           printf (" %d", val);
13631                         }
13632                       printf ("\n");
13633                       break;
13634                     default:
13635                       printf (_("Unknown tag: %d\n"), tag);
13636                       public_section = FALSE;
13637                       break;
13638                     }
13639
13640                   if (public_section && display_pub_attribute != NULL)
13641                     {
13642                       while (p < end)
13643                         p = display_pub_attribute (p, end);
13644                       assert (p <= end);
13645                     }
13646                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13647                     {
13648                       while (p < end)
13649                         p = display_gnu_attribute (p,
13650                                                    display_proc_gnu_attribute,
13651                                                    end);
13652                       assert (p <= end);
13653                     }
13654                   else if (p < end)
13655                     {
13656                       printf (_("  Unknown attribute:\n"));
13657                       display_raw_attribute (p, end);
13658                       p = end;
13659                     }
13660                   else
13661                     attr_len = 0;
13662                 }
13663             }
13664         }
13665       else
13666         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13667
13668       free (contents);
13669     }
13670   return 1;
13671 }
13672
13673 static int
13674 process_arm_specific (FILE * file)
13675 {
13676   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13677                              display_arm_attribute, NULL);
13678 }
13679
13680 static int
13681 process_power_specific (FILE * file)
13682 {
13683   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13684                              display_power_gnu_attribute);
13685 }
13686
13687 static int
13688 process_s390_specific (FILE * file)
13689 {
13690   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13691                              display_s390_gnu_attribute);
13692 }
13693
13694 static int
13695 process_sparc_specific (FILE * file)
13696 {
13697   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13698                              display_sparc_gnu_attribute);
13699 }
13700
13701 static int
13702 process_tic6x_specific (FILE * file)
13703 {
13704   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13705                              display_tic6x_attribute, NULL);
13706 }
13707
13708 static int
13709 process_msp430x_specific (FILE * file)
13710 {
13711   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13712                              display_msp430x_attribute, NULL);
13713 }
13714
13715 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13716    Print the Address, Access and Initial fields of an entry at VMA ADDR
13717    and return the VMA of the next entry, or -1 if there was a problem.
13718    Does not read from DATA_END or beyond.  */
13719
13720 static bfd_vma
13721 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13722                       unsigned char * data_end)
13723 {
13724   printf ("  ");
13725   print_vma (addr, LONG_HEX);
13726   printf (" ");
13727   if (addr < pltgot + 0xfff0)
13728     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13729   else
13730     printf ("%10s", "");
13731   printf (" ");
13732   if (data == NULL)
13733     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13734   else
13735     {
13736       bfd_vma entry;
13737       unsigned char * from = data + addr - pltgot;
13738
13739       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13740         {
13741           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13742           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13743           return (bfd_vma) -1;
13744         }
13745       else
13746         {
13747           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13748           print_vma (entry, LONG_HEX);
13749         }
13750     }
13751   return addr + (is_32bit_elf ? 4 : 8);
13752 }
13753
13754 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13755    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13756    ADDR and return the VMA of the next entry.  */
13757
13758 static bfd_vma
13759 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13760 {
13761   printf ("  ");
13762   print_vma (addr, LONG_HEX);
13763   printf (" ");
13764   if (data == NULL)
13765     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13766   else
13767     {
13768       bfd_vma entry;
13769
13770       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13771       print_vma (entry, LONG_HEX);
13772     }
13773   return addr + (is_32bit_elf ? 4 : 8);
13774 }
13775
13776 static void
13777 print_mips_ases (unsigned int mask)
13778 {
13779   if (mask & AFL_ASE_DSP)
13780     fputs ("\n\tDSP ASE", stdout);
13781   if (mask & AFL_ASE_DSPR2)
13782     fputs ("\n\tDSP R2 ASE", stdout);
13783   if (mask & AFL_ASE_EVA)
13784     fputs ("\n\tEnhanced VA Scheme", stdout);
13785   if (mask & AFL_ASE_MCU)
13786     fputs ("\n\tMCU (MicroController) ASE", stdout);
13787   if (mask & AFL_ASE_MDMX)
13788     fputs ("\n\tMDMX ASE", stdout);
13789   if (mask & AFL_ASE_MIPS3D)
13790     fputs ("\n\tMIPS-3D ASE", stdout);
13791   if (mask & AFL_ASE_MT)
13792     fputs ("\n\tMT ASE", stdout);
13793   if (mask & AFL_ASE_SMARTMIPS)
13794     fputs ("\n\tSmartMIPS ASE", stdout);
13795   if (mask & AFL_ASE_VIRT)
13796     fputs ("\n\tVZ ASE", stdout);
13797   if (mask & AFL_ASE_MSA)
13798     fputs ("\n\tMSA ASE", stdout);
13799   if (mask & AFL_ASE_MIPS16)
13800     fputs ("\n\tMIPS16 ASE", stdout);
13801   if (mask & AFL_ASE_MICROMIPS)
13802     fputs ("\n\tMICROMIPS ASE", stdout);
13803   if (mask & AFL_ASE_XPA)
13804     fputs ("\n\tXPA ASE", stdout);
13805   if (mask == 0)
13806     fprintf (stdout, "\n\t%s", _("None"));
13807   else if ((mask & ~AFL_ASE_MASK) != 0)
13808     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13809 }
13810
13811 static void
13812 print_mips_isa_ext (unsigned int isa_ext)
13813 {
13814   switch (isa_ext)
13815     {
13816     case 0:
13817       fputs (_("None"), stdout);
13818       break;
13819     case AFL_EXT_XLR:
13820       fputs ("RMI XLR", stdout);
13821       break;
13822     case AFL_EXT_OCTEON3:
13823       fputs ("Cavium Networks Octeon3", stdout);
13824       break;
13825     case AFL_EXT_OCTEON2:
13826       fputs ("Cavium Networks Octeon2", stdout);
13827       break;
13828     case AFL_EXT_OCTEONP:
13829       fputs ("Cavium Networks OcteonP", stdout);
13830       break;
13831     case AFL_EXT_LOONGSON_3A:
13832       fputs ("Loongson 3A", stdout);
13833       break;
13834     case AFL_EXT_OCTEON:
13835       fputs ("Cavium Networks Octeon", stdout);
13836       break;
13837     case AFL_EXT_5900:
13838       fputs ("Toshiba R5900", stdout);
13839       break;
13840     case AFL_EXT_4650:
13841       fputs ("MIPS R4650", stdout);
13842       break;
13843     case AFL_EXT_4010:
13844       fputs ("LSI R4010", stdout);
13845       break;
13846     case AFL_EXT_4100:
13847       fputs ("NEC VR4100", stdout);
13848       break;
13849     case AFL_EXT_3900:
13850       fputs ("Toshiba R3900", stdout);
13851       break;
13852     case AFL_EXT_10000:
13853       fputs ("MIPS R10000", stdout);
13854       break;
13855     case AFL_EXT_SB1:
13856       fputs ("Broadcom SB-1", stdout);
13857       break;
13858     case AFL_EXT_4111:
13859       fputs ("NEC VR4111/VR4181", stdout);
13860       break;
13861     case AFL_EXT_4120:
13862       fputs ("NEC VR4120", stdout);
13863       break;
13864     case AFL_EXT_5400:
13865       fputs ("NEC VR5400", stdout);
13866       break;
13867     case AFL_EXT_5500:
13868       fputs ("NEC VR5500", stdout);
13869       break;
13870     case AFL_EXT_LOONGSON_2E:
13871       fputs ("ST Microelectronics Loongson 2E", stdout);
13872       break;
13873     case AFL_EXT_LOONGSON_2F:
13874       fputs ("ST Microelectronics Loongson 2F", stdout);
13875       break;
13876     default:
13877       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13878     }
13879 }
13880
13881 static int
13882 get_mips_reg_size (int reg_size)
13883 {
13884   return (reg_size == AFL_REG_NONE) ? 0
13885          : (reg_size == AFL_REG_32) ? 32
13886          : (reg_size == AFL_REG_64) ? 64
13887          : (reg_size == AFL_REG_128) ? 128
13888          : -1;
13889 }
13890
13891 static int
13892 process_mips_specific (FILE * file)
13893 {
13894   Elf_Internal_Dyn * entry;
13895   Elf_Internal_Shdr *sect = NULL;
13896   size_t liblist_offset = 0;
13897   size_t liblistno = 0;
13898   size_t conflictsno = 0;
13899   size_t options_offset = 0;
13900   size_t conflicts_offset = 0;
13901   size_t pltrelsz = 0;
13902   size_t pltrel = 0;
13903   bfd_vma pltgot = 0;
13904   bfd_vma mips_pltgot = 0;
13905   bfd_vma jmprel = 0;
13906   bfd_vma local_gotno = 0;
13907   bfd_vma gotsym = 0;
13908   bfd_vma symtabno = 0;
13909
13910   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13911                       display_mips_gnu_attribute);
13912
13913   sect = find_section (".MIPS.abiflags");
13914
13915   if (sect != NULL)
13916     {
13917       Elf_External_ABIFlags_v0 *abiflags_ext;
13918       Elf_Internal_ABIFlags_v0 abiflags_in;
13919
13920       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13921         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13922       else
13923         {
13924           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13925                                    sect->sh_size, _("MIPS ABI Flags section"));
13926           if (abiflags_ext)
13927             {
13928               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13929               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13930               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13931               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13932               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13933               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13934               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13935               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13936               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13937               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13938               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13939
13940               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13941               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13942               if (abiflags_in.isa_rev > 1)
13943                 printf ("r%d", abiflags_in.isa_rev);
13944               printf ("\nGPR size: %d",
13945                       get_mips_reg_size (abiflags_in.gpr_size));
13946               printf ("\nCPR1 size: %d",
13947                       get_mips_reg_size (abiflags_in.cpr1_size));
13948               printf ("\nCPR2 size: %d",
13949                       get_mips_reg_size (abiflags_in.cpr2_size));
13950               fputs ("\nFP ABI: ", stdout);
13951               print_mips_fp_abi_value (abiflags_in.fp_abi);
13952               fputs ("ISA Extension: ", stdout);
13953               print_mips_isa_ext (abiflags_in.isa_ext);
13954               fputs ("\nASEs:", stdout);
13955               print_mips_ases (abiflags_in.ases);
13956               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13957               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13958               fputc ('\n', stdout);
13959               free (abiflags_ext);
13960             }
13961         }
13962     }
13963
13964   /* We have a lot of special sections.  Thanks SGI!  */
13965   if (dynamic_section == NULL)
13966     /* No information available.  */
13967     return 0;
13968
13969   for (entry = dynamic_section;
13970        /* PR 17531 file: 012-50589-0.004.  */
13971        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13972        ++entry)
13973     switch (entry->d_tag)
13974       {
13975       case DT_MIPS_LIBLIST:
13976         liblist_offset
13977           = offset_from_vma (file, entry->d_un.d_val,
13978                              liblistno * sizeof (Elf32_External_Lib));
13979         break;
13980       case DT_MIPS_LIBLISTNO:
13981         liblistno = entry->d_un.d_val;
13982         break;
13983       case DT_MIPS_OPTIONS:
13984         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13985         break;
13986       case DT_MIPS_CONFLICT:
13987         conflicts_offset
13988           = offset_from_vma (file, entry->d_un.d_val,
13989                              conflictsno * sizeof (Elf32_External_Conflict));
13990         break;
13991       case DT_MIPS_CONFLICTNO:
13992         conflictsno = entry->d_un.d_val;
13993         break;
13994       case DT_PLTGOT:
13995         pltgot = entry->d_un.d_ptr;
13996         break;
13997       case DT_MIPS_LOCAL_GOTNO:
13998         local_gotno = entry->d_un.d_val;
13999         break;
14000       case DT_MIPS_GOTSYM:
14001         gotsym = entry->d_un.d_val;
14002         break;
14003       case DT_MIPS_SYMTABNO:
14004         symtabno = entry->d_un.d_val;
14005         break;
14006       case DT_MIPS_PLTGOT:
14007         mips_pltgot = entry->d_un.d_ptr;
14008         break;
14009       case DT_PLTREL:
14010         pltrel = entry->d_un.d_val;
14011         break;
14012       case DT_PLTRELSZ:
14013         pltrelsz = entry->d_un.d_val;
14014         break;
14015       case DT_JMPREL:
14016         jmprel = entry->d_un.d_ptr;
14017         break;
14018       default:
14019         break;
14020       }
14021
14022   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14023     {
14024       Elf32_External_Lib * elib;
14025       size_t cnt;
14026
14027       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14028                                               liblistno,
14029                                               sizeof (Elf32_External_Lib),
14030                                               _("liblist section data"));
14031       if (elib)
14032         {
14033           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14034                   (unsigned long) liblistno);
14035           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14036                  stdout);
14037
14038           for (cnt = 0; cnt < liblistno; ++cnt)
14039             {
14040               Elf32_Lib liblist;
14041               time_t atime;
14042               char timebuf[20];
14043               struct tm * tmp;
14044
14045               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14046               atime = BYTE_GET (elib[cnt].l_time_stamp);
14047               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14048               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14049               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14050
14051               tmp = gmtime (&atime);
14052               snprintf (timebuf, sizeof (timebuf),
14053                         "%04u-%02u-%02uT%02u:%02u:%02u",
14054                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14055                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14056
14057               printf ("%3lu: ", (unsigned long) cnt);
14058               if (VALID_DYNAMIC_NAME (liblist.l_name))
14059                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14060               else
14061                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14062               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14063                       liblist.l_version);
14064
14065               if (liblist.l_flags == 0)
14066                 puts (_(" NONE"));
14067               else
14068                 {
14069                   static const struct
14070                   {
14071                     const char * name;
14072                     int bit;
14073                   }
14074                   l_flags_vals[] =
14075                   {
14076                     { " EXACT_MATCH", LL_EXACT_MATCH },
14077                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14078                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14079                     { " EXPORTS", LL_EXPORTS },
14080                     { " DELAY_LOAD", LL_DELAY_LOAD },
14081                     { " DELTA", LL_DELTA }
14082                   };
14083                   int flags = liblist.l_flags;
14084                   size_t fcnt;
14085
14086                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14087                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14088                       {
14089                         fputs (l_flags_vals[fcnt].name, stdout);
14090                         flags ^= l_flags_vals[fcnt].bit;
14091                       }
14092                   if (flags != 0)
14093                     printf (" %#x", (unsigned int) flags);
14094
14095                   puts ("");
14096                 }
14097             }
14098
14099           free (elib);
14100         }
14101     }
14102
14103   if (options_offset != 0)
14104     {
14105       Elf_External_Options * eopt;
14106       Elf_Internal_Options * iopt;
14107       Elf_Internal_Options * option;
14108       size_t offset;
14109       int cnt;
14110       sect = section_headers;
14111
14112       /* Find the section header so that we get the size.  */
14113       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14114       /* PR 17533 file: 012-277276-0.004.  */
14115       if (sect == NULL)
14116         {
14117           error (_("No MIPS_OPTIONS header found\n"));
14118           return 0;
14119         }
14120
14121       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14122                                                 sect->sh_size, _("options"));
14123       if (eopt)
14124         {
14125           iopt = (Elf_Internal_Options *)
14126               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14127           if (iopt == NULL)
14128             {
14129               error (_("Out of memory allocatinf space for MIPS options\n"));
14130               return 0;
14131             }
14132
14133           offset = cnt = 0;
14134           option = iopt;
14135
14136           while (offset <= sect->sh_size - sizeof (* eopt))
14137             {
14138               Elf_External_Options * eoption;
14139
14140               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14141
14142               option->kind = BYTE_GET (eoption->kind);
14143               option->size = BYTE_GET (eoption->size);
14144               option->section = BYTE_GET (eoption->section);
14145               option->info = BYTE_GET (eoption->info);
14146
14147               /* PR 17531: file: ffa0fa3b.  */
14148               if (option->size < sizeof (* eopt)
14149                   || offset + option->size > sect->sh_size)
14150                 {
14151                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14152                   return 0;
14153                 }
14154               offset += option->size;
14155
14156               ++option;
14157               ++cnt;
14158             }
14159
14160           printf (_("\nSection '%s' contains %d entries:\n"),
14161                   printable_section_name (sect), cnt);
14162
14163           option = iopt;
14164           offset = 0;
14165
14166           while (cnt-- > 0)
14167             {
14168               size_t len;
14169
14170               switch (option->kind)
14171                 {
14172                 case ODK_NULL:
14173                   /* This shouldn't happen.  */
14174                   printf (" NULL       %d %lx", option->section, option->info);
14175                   break;
14176                 case ODK_REGINFO:
14177                   printf (" REGINFO    ");
14178                   if (elf_header.e_machine == EM_MIPS)
14179                     {
14180                       /* 32bit form.  */
14181                       Elf32_External_RegInfo * ereg;
14182                       Elf32_RegInfo reginfo;
14183
14184                       ereg = (Elf32_External_RegInfo *) (option + 1);
14185                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14186                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14187                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14188                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14189                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14190                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14191
14192                       printf ("GPR %08lx  GP 0x%lx\n",
14193                               reginfo.ri_gprmask,
14194                               (unsigned long) reginfo.ri_gp_value);
14195                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14196                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14197                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14198                     }
14199                   else
14200                     {
14201                       /* 64 bit form.  */
14202                       Elf64_External_RegInfo * ereg;
14203                       Elf64_Internal_RegInfo reginfo;
14204
14205                       ereg = (Elf64_External_RegInfo *) (option + 1);
14206                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14207                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14208                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14209                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14210                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14211                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14212
14213                       printf ("GPR %08lx  GP 0x",
14214                               reginfo.ri_gprmask);
14215                       printf_vma (reginfo.ri_gp_value);
14216                       printf ("\n");
14217
14218                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14219                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14220                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14221                     }
14222                   ++option;
14223                   continue;
14224                 case ODK_EXCEPTIONS:
14225                   fputs (" EXCEPTIONS fpe_min(", stdout);
14226                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14227                   fputs (") fpe_max(", stdout);
14228                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14229                   fputs (")", stdout);
14230
14231                   if (option->info & OEX_PAGE0)
14232                     fputs (" PAGE0", stdout);
14233                   if (option->info & OEX_SMM)
14234                     fputs (" SMM", stdout);
14235                   if (option->info & OEX_FPDBUG)
14236                     fputs (" FPDBUG", stdout);
14237                   if (option->info & OEX_DISMISS)
14238                     fputs (" DISMISS", stdout);
14239                   break;
14240                 case ODK_PAD:
14241                   fputs (" PAD       ", stdout);
14242                   if (option->info & OPAD_PREFIX)
14243                     fputs (" PREFIX", stdout);
14244                   if (option->info & OPAD_POSTFIX)
14245                     fputs (" POSTFIX", stdout);
14246                   if (option->info & OPAD_SYMBOL)
14247                     fputs (" SYMBOL", stdout);
14248                   break;
14249                 case ODK_HWPATCH:
14250                   fputs (" HWPATCH   ", stdout);
14251                   if (option->info & OHW_R4KEOP)
14252                     fputs (" R4KEOP", stdout);
14253                   if (option->info & OHW_R8KPFETCH)
14254                     fputs (" R8KPFETCH", stdout);
14255                   if (option->info & OHW_R5KEOP)
14256                     fputs (" R5KEOP", stdout);
14257                   if (option->info & OHW_R5KCVTL)
14258                     fputs (" R5KCVTL", stdout);
14259                   break;
14260                 case ODK_FILL:
14261                   fputs (" FILL       ", stdout);
14262                   /* XXX Print content of info word?  */
14263                   break;
14264                 case ODK_TAGS:
14265                   fputs (" TAGS       ", stdout);
14266                   /* XXX Print content of info word?  */
14267                   break;
14268                 case ODK_HWAND:
14269                   fputs (" HWAND     ", stdout);
14270                   if (option->info & OHWA0_R4KEOP_CHECKED)
14271                     fputs (" R4KEOP_CHECKED", stdout);
14272                   if (option->info & OHWA0_R4KEOP_CLEAN)
14273                     fputs (" R4KEOP_CLEAN", stdout);
14274                   break;
14275                 case ODK_HWOR:
14276                   fputs (" HWOR      ", stdout);
14277                   if (option->info & OHWA0_R4KEOP_CHECKED)
14278                     fputs (" R4KEOP_CHECKED", stdout);
14279                   if (option->info & OHWA0_R4KEOP_CLEAN)
14280                     fputs (" R4KEOP_CLEAN", stdout);
14281                   break;
14282                 case ODK_GP_GROUP:
14283                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14284                           option->info & OGP_GROUP,
14285                           (option->info & OGP_SELF) >> 16);
14286                   break;
14287                 case ODK_IDENT:
14288                   printf (" IDENT     %#06lx  self-contained %#06lx",
14289                           option->info & OGP_GROUP,
14290                           (option->info & OGP_SELF) >> 16);
14291                   break;
14292                 default:
14293                   /* This shouldn't happen.  */
14294                   printf (" %3d ???     %d %lx",
14295                           option->kind, option->section, option->info);
14296                   break;
14297                 }
14298
14299               len = sizeof (* eopt);
14300               while (len < option->size)
14301                 {
14302                   char datum = * ((char *) eopt + offset + len);
14303
14304                   if (ISPRINT (datum))
14305                     printf ("%c", datum);
14306                   else
14307                     printf ("\\%03o", datum);
14308                   len ++;
14309                 }
14310               fputs ("\n", stdout);
14311
14312               offset += option->size;
14313               ++option;
14314             }
14315
14316           free (eopt);
14317         }
14318     }
14319
14320   if (conflicts_offset != 0 && conflictsno != 0)
14321     {
14322       Elf32_Conflict * iconf;
14323       size_t cnt;
14324
14325       if (dynamic_symbols == NULL)
14326         {
14327           error (_("conflict list found without a dynamic symbol table\n"));
14328           return 0;
14329         }
14330
14331       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14332       if (iconf == NULL)
14333         {
14334           error (_("Out of memory allocating space for dynamic conflicts\n"));
14335           return 0;
14336         }
14337
14338       if (is_32bit_elf)
14339         {
14340           Elf32_External_Conflict * econf32;
14341
14342           econf32 = (Elf32_External_Conflict *)
14343               get_data (NULL, file, conflicts_offset, conflictsno,
14344                         sizeof (* econf32), _("conflict"));
14345           if (!econf32)
14346             return 0;
14347
14348           for (cnt = 0; cnt < conflictsno; ++cnt)
14349             iconf[cnt] = BYTE_GET (econf32[cnt]);
14350
14351           free (econf32);
14352         }
14353       else
14354         {
14355           Elf64_External_Conflict * econf64;
14356
14357           econf64 = (Elf64_External_Conflict *)
14358               get_data (NULL, file, conflicts_offset, conflictsno,
14359                         sizeof (* econf64), _("conflict"));
14360           if (!econf64)
14361             return 0;
14362
14363           for (cnt = 0; cnt < conflictsno; ++cnt)
14364             iconf[cnt] = BYTE_GET (econf64[cnt]);
14365
14366           free (econf64);
14367         }
14368
14369       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14370               (unsigned long) conflictsno);
14371       puts (_("  Num:    Index       Value  Name"));
14372
14373       for (cnt = 0; cnt < conflictsno; ++cnt)
14374         {
14375           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14376
14377           if (iconf[cnt] >= num_dynamic_syms)
14378             printf (_("<corrupt symbol index>"));
14379           else
14380             {
14381               Elf_Internal_Sym * psym;
14382
14383               psym = & dynamic_symbols[iconf[cnt]];
14384               print_vma (psym->st_value, FULL_HEX);
14385               putchar (' ');
14386               if (VALID_DYNAMIC_NAME (psym->st_name))
14387                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14388               else
14389                 printf (_("<corrupt: %14ld>"), psym->st_name);
14390             }
14391           putchar ('\n');
14392         }
14393
14394       free (iconf);
14395     }
14396
14397   if (pltgot != 0 && local_gotno != 0)
14398     {
14399       bfd_vma ent, local_end, global_end;
14400       size_t i, offset;
14401       unsigned char * data;
14402       unsigned char * data_end;
14403       int addr_size;
14404
14405       ent = pltgot;
14406       addr_size = (is_32bit_elf ? 4 : 8);
14407       local_end = pltgot + local_gotno * addr_size;
14408
14409       /* PR binutils/17533 file: 012-111227-0.004  */
14410       if (symtabno < gotsym)
14411         {
14412           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14413                  (unsigned long) gotsym, (unsigned long) symtabno);
14414           return 0;
14415         }
14416
14417       global_end = local_end + (symtabno - gotsym) * addr_size;
14418       /* PR 17531: file: 54c91a34.  */
14419       if (global_end < local_end)
14420         {
14421           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14422           return 0;
14423         }
14424
14425       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14426       data = (unsigned char *) get_data (NULL, file, offset,
14427                                          global_end - pltgot, 1,
14428                                          _("Global Offset Table data"));
14429       if (data == NULL)
14430         return 0;
14431       data_end = data + (global_end - pltgot);
14432
14433       printf (_("\nPrimary GOT:\n"));
14434       printf (_(" Canonical gp value: "));
14435       print_vma (pltgot + 0x7ff0, LONG_HEX);
14436       printf ("\n\n");
14437
14438       printf (_(" Reserved entries:\n"));
14439       printf (_("  %*s %10s %*s Purpose\n"),
14440               addr_size * 2, _("Address"), _("Access"),
14441               addr_size * 2, _("Initial"));
14442       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14443       printf (_(" Lazy resolver\n"));
14444       if (ent == (bfd_vma) -1)
14445         goto got_print_fail;
14446       if (data
14447           && (byte_get (data + ent - pltgot, addr_size)
14448               >> (addr_size * 8 - 1)) != 0)
14449         {
14450           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14451           printf (_(" Module pointer (GNU extension)\n"));
14452           if (ent == (bfd_vma) -1)
14453             goto got_print_fail;
14454         }
14455       printf ("\n");
14456
14457       if (ent < local_end)
14458         {
14459           printf (_(" Local entries:\n"));
14460           printf ("  %*s %10s %*s\n",
14461                   addr_size * 2, _("Address"), _("Access"),
14462                   addr_size * 2, _("Initial"));
14463           while (ent < local_end)
14464             {
14465               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14466               printf ("\n");
14467               if (ent == (bfd_vma) -1)
14468                 goto got_print_fail;
14469             }
14470           printf ("\n");
14471         }
14472
14473       if (gotsym < symtabno)
14474         {
14475           int sym_width;
14476
14477           printf (_(" Global entries:\n"));
14478           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14479                   addr_size * 2, _("Address"),
14480                   _("Access"),
14481                   addr_size * 2, _("Initial"),
14482                   addr_size * 2, _("Sym.Val."),
14483                   _("Type"),
14484                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14485                   _("Ndx"), _("Name"));
14486
14487           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14488
14489           for (i = gotsym; i < symtabno; i++)
14490             {
14491               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14492               printf (" ");
14493
14494               if (dynamic_symbols == NULL)
14495                 printf (_("<no dynamic symbols>"));
14496               else if (i < num_dynamic_syms)
14497                 {
14498                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14499
14500                   print_vma (psym->st_value, LONG_HEX);
14501                   printf (" %-7s %3s ",
14502                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14503                           get_symbol_index_type (psym->st_shndx));
14504
14505                   if (VALID_DYNAMIC_NAME (psym->st_name))
14506                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14507                   else
14508                     printf (_("<corrupt: %14ld>"), psym->st_name);
14509                 }
14510               else
14511                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14512                         (unsigned long) i);
14513
14514               printf ("\n");
14515               if (ent == (bfd_vma) -1)
14516                 break;
14517             }
14518           printf ("\n");
14519         }
14520
14521     got_print_fail:
14522       if (data)
14523         free (data);
14524     }
14525
14526   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14527     {
14528       bfd_vma ent, end;
14529       size_t offset, rel_offset;
14530       unsigned long count, i;
14531       unsigned char * data;
14532       int addr_size, sym_width;
14533       Elf_Internal_Rela * rels;
14534
14535       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14536       if (pltrel == DT_RELA)
14537         {
14538           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14539             return 0;
14540         }
14541       else
14542         {
14543           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14544             return 0;
14545         }
14546
14547       ent = mips_pltgot;
14548       addr_size = (is_32bit_elf ? 4 : 8);
14549       end = mips_pltgot + (2 + count) * addr_size;
14550
14551       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14552       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14553                                          1, _("Procedure Linkage Table data"));
14554       if (data == NULL)
14555         return 0;
14556
14557       printf ("\nPLT GOT:\n\n");
14558       printf (_(" Reserved entries:\n"));
14559       printf (_("  %*s %*s Purpose\n"),
14560               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14561       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14562       printf (_(" PLT lazy resolver\n"));
14563       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14564       printf (_(" Module pointer\n"));
14565       printf ("\n");
14566
14567       printf (_(" Entries:\n"));
14568       printf ("  %*s %*s %*s %-7s %3s %s\n",
14569               addr_size * 2, _("Address"),
14570               addr_size * 2, _("Initial"),
14571               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14572       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14573       for (i = 0; i < count; i++)
14574         {
14575           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14576
14577           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14578           printf (" ");
14579
14580           if (idx >= num_dynamic_syms)
14581             printf (_("<corrupt symbol index: %lu>"), idx);
14582           else
14583             {
14584               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14585
14586               print_vma (psym->st_value, LONG_HEX);
14587               printf (" %-7s %3s ",
14588                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14589                       get_symbol_index_type (psym->st_shndx));
14590               if (VALID_DYNAMIC_NAME (psym->st_name))
14591                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14592               else
14593                 printf (_("<corrupt: %14ld>"), psym->st_name);
14594             }
14595           printf ("\n");
14596         }
14597       printf ("\n");
14598
14599       if (data)
14600         free (data);
14601       free (rels);
14602     }
14603
14604   return 1;
14605 }
14606
14607 static int
14608 process_nds32_specific (FILE * file)
14609 {
14610   Elf_Internal_Shdr *sect = NULL;
14611
14612   sect = find_section (".nds32_e_flags");
14613   if (sect != NULL)
14614     {
14615       unsigned int *flag;
14616
14617       printf ("\nNDS32 elf flags section:\n");
14618       flag = get_data (NULL, file, sect->sh_offset, 1,
14619                        sect->sh_size, _("NDS32 elf flags section"));
14620
14621       switch ((*flag) & 0x3)
14622         {
14623         case 0:
14624           printf ("(VEC_SIZE):\tNo entry.\n");
14625           break;
14626         case 1:
14627           printf ("(VEC_SIZE):\t4 bytes\n");
14628           break;
14629         case 2:
14630           printf ("(VEC_SIZE):\t16 bytes\n");
14631           break;
14632         case 3:
14633           printf ("(VEC_SIZE):\treserved\n");
14634           break;
14635         }
14636     }
14637
14638   return TRUE;
14639 }
14640
14641 static int
14642 process_gnu_liblist (FILE * file)
14643 {
14644   Elf_Internal_Shdr * section;
14645   Elf_Internal_Shdr * string_sec;
14646   Elf32_External_Lib * elib;
14647   char * strtab;
14648   size_t strtab_size;
14649   size_t cnt;
14650   unsigned i;
14651
14652   if (! do_arch)
14653     return 0;
14654
14655   for (i = 0, section = section_headers;
14656        i < elf_header.e_shnum;
14657        i++, section++)
14658     {
14659       switch (section->sh_type)
14660         {
14661         case SHT_GNU_LIBLIST:
14662           if (section->sh_link >= elf_header.e_shnum)
14663             break;
14664
14665           elib = (Elf32_External_Lib *)
14666               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14667                         _("liblist section data"));
14668
14669           if (elib == NULL)
14670             break;
14671           string_sec = section_headers + section->sh_link;
14672
14673           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14674                                       string_sec->sh_size,
14675                                       _("liblist string table"));
14676           if (strtab == NULL
14677               || section->sh_entsize != sizeof (Elf32_External_Lib))
14678             {
14679               free (elib);
14680               free (strtab);
14681               break;
14682             }
14683           strtab_size = string_sec->sh_size;
14684
14685           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14686                   printable_section_name (section),
14687                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14688
14689           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14690
14691           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14692                ++cnt)
14693             {
14694               Elf32_Lib liblist;
14695               time_t atime;
14696               char timebuf[20];
14697               struct tm * tmp;
14698
14699               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14700               atime = BYTE_GET (elib[cnt].l_time_stamp);
14701               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14702               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14703               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14704
14705               tmp = gmtime (&atime);
14706               snprintf (timebuf, sizeof (timebuf),
14707                         "%04u-%02u-%02uT%02u:%02u:%02u",
14708                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14709                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14710
14711               printf ("%3lu: ", (unsigned long) cnt);
14712               if (do_wide)
14713                 printf ("%-20s", liblist.l_name < strtab_size
14714                         ? strtab + liblist.l_name : _("<corrupt>"));
14715               else
14716                 printf ("%-20.20s", liblist.l_name < strtab_size
14717                         ? strtab + liblist.l_name : _("<corrupt>"));
14718               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14719                       liblist.l_version, liblist.l_flags);
14720             }
14721
14722           free (elib);
14723           free (strtab);
14724         }
14725     }
14726
14727   return 1;
14728 }
14729
14730 static const char *
14731 get_note_type (unsigned e_type)
14732 {
14733   static char buff[64];
14734
14735   if (elf_header.e_type == ET_CORE)
14736     switch (e_type)
14737       {
14738       case NT_AUXV:
14739         return _("NT_AUXV (auxiliary vector)");
14740       case NT_PRSTATUS:
14741         return _("NT_PRSTATUS (prstatus structure)");
14742       case NT_FPREGSET:
14743         return _("NT_FPREGSET (floating point registers)");
14744       case NT_PRPSINFO:
14745         return _("NT_PRPSINFO (prpsinfo structure)");
14746       case NT_TASKSTRUCT:
14747         return _("NT_TASKSTRUCT (task structure)");
14748       case NT_PRXFPREG:
14749         return _("NT_PRXFPREG (user_xfpregs structure)");
14750       case NT_PPC_VMX:
14751         return _("NT_PPC_VMX (ppc Altivec registers)");
14752       case NT_PPC_VSX:
14753         return _("NT_PPC_VSX (ppc VSX registers)");
14754       case NT_386_TLS:
14755         return _("NT_386_TLS (x86 TLS information)");
14756       case NT_386_IOPERM:
14757         return _("NT_386_IOPERM (x86 I/O permissions)");
14758       case NT_X86_XSTATE:
14759         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14760       case NT_S390_HIGH_GPRS:
14761         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14762       case NT_S390_TIMER:
14763         return _("NT_S390_TIMER (s390 timer register)");
14764       case NT_S390_TODCMP:
14765         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14766       case NT_S390_TODPREG:
14767         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14768       case NT_S390_CTRS:
14769         return _("NT_S390_CTRS (s390 control registers)");
14770       case NT_S390_PREFIX:
14771         return _("NT_S390_PREFIX (s390 prefix register)");
14772       case NT_S390_LAST_BREAK:
14773         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14774       case NT_S390_SYSTEM_CALL:
14775         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14776       case NT_S390_TDB:
14777         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14778       case NT_S390_VXRS_LOW:
14779         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14780       case NT_S390_VXRS_HIGH:
14781         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14782       case NT_ARM_VFP:
14783         return _("NT_ARM_VFP (arm VFP registers)");
14784       case NT_ARM_TLS:
14785         return _("NT_ARM_TLS (AArch TLS registers)");
14786       case NT_ARM_HW_BREAK:
14787         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14788       case NT_ARM_HW_WATCH:
14789         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14790       case NT_PSTATUS:
14791         return _("NT_PSTATUS (pstatus structure)");
14792       case NT_FPREGS:
14793         return _("NT_FPREGS (floating point registers)");
14794       case NT_PSINFO:
14795         return _("NT_PSINFO (psinfo structure)");
14796       case NT_LWPSTATUS:
14797         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14798       case NT_LWPSINFO:
14799         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14800       case NT_WIN32PSTATUS:
14801         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14802       case NT_SIGINFO:
14803         return _("NT_SIGINFO (siginfo_t data)");
14804       case NT_FILE:
14805         return _("NT_FILE (mapped files)");
14806       default:
14807         break;
14808       }
14809   else
14810     switch (e_type)
14811       {
14812       case NT_VERSION:
14813         return _("NT_VERSION (version)");
14814       case NT_ARCH:
14815         return _("NT_ARCH (architecture)");
14816       default:
14817         break;
14818       }
14819
14820   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14821   return buff;
14822 }
14823
14824 static int
14825 print_core_note (Elf_Internal_Note *pnote)
14826 {
14827   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14828   bfd_vma count, page_size;
14829   unsigned char *descdata, *filenames, *descend;
14830
14831   if (pnote->type != NT_FILE)
14832     return 1;
14833
14834 #ifndef BFD64
14835   if (!is_32bit_elf)
14836     {
14837       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14838       /* Still "successful".  */
14839       return 1;
14840     }
14841 #endif
14842
14843   if (pnote->descsz < 2 * addr_size)
14844     {
14845       printf (_("    Malformed note - too short for header\n"));
14846       return 0;
14847     }
14848
14849   descdata = (unsigned char *) pnote->descdata;
14850   descend = descdata + pnote->descsz;
14851
14852   if (descdata[pnote->descsz - 1] != '\0')
14853     {
14854       printf (_("    Malformed note - does not end with \\0\n"));
14855       return 0;
14856     }
14857
14858   count = byte_get (descdata, addr_size);
14859   descdata += addr_size;
14860
14861   page_size = byte_get (descdata, addr_size);
14862   descdata += addr_size;
14863
14864   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14865     {
14866       printf (_("    Malformed note - too short for supplied file count\n"));
14867       return 0;
14868     }
14869
14870   printf (_("    Page size: "));
14871   print_vma (page_size, DEC);
14872   printf ("\n");
14873
14874   printf (_("    %*s%*s%*s\n"),
14875           (int) (2 + 2 * addr_size), _("Start"),
14876           (int) (4 + 2 * addr_size), _("End"),
14877           (int) (4 + 2 * addr_size), _("Page Offset"));
14878   filenames = descdata + count * 3 * addr_size;
14879   while (--count > 0)
14880     {
14881       bfd_vma start, end, file_ofs;
14882
14883       if (filenames == descend)
14884         {
14885           printf (_("    Malformed note - filenames end too early\n"));
14886           return 0;
14887         }
14888
14889       start = byte_get (descdata, addr_size);
14890       descdata += addr_size;
14891       end = byte_get (descdata, addr_size);
14892       descdata += addr_size;
14893       file_ofs = byte_get (descdata, addr_size);
14894       descdata += addr_size;
14895
14896       printf ("    ");
14897       print_vma (start, FULL_HEX);
14898       printf ("  ");
14899       print_vma (end, FULL_HEX);
14900       printf ("  ");
14901       print_vma (file_ofs, FULL_HEX);
14902       printf ("\n        %s\n", filenames);
14903
14904       filenames += 1 + strlen ((char *) filenames);
14905     }
14906
14907   return 1;
14908 }
14909
14910 static const char *
14911 get_gnu_elf_note_type (unsigned e_type)
14912 {
14913   static char buff[64];
14914
14915   switch (e_type)
14916     {
14917     case NT_GNU_ABI_TAG:
14918       return _("NT_GNU_ABI_TAG (ABI version tag)");
14919     case NT_GNU_HWCAP:
14920       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14921     case NT_GNU_BUILD_ID:
14922       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14923     case NT_GNU_GOLD_VERSION:
14924       return _("NT_GNU_GOLD_VERSION (gold version)");
14925     default:
14926       break;
14927     }
14928
14929   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14930   return buff;
14931 }
14932
14933 static int
14934 print_gnu_note (Elf_Internal_Note *pnote)
14935 {
14936   switch (pnote->type)
14937     {
14938     case NT_GNU_BUILD_ID:
14939       {
14940         unsigned long i;
14941
14942         printf (_("    Build ID: "));
14943         for (i = 0; i < pnote->descsz; ++i)
14944           printf ("%02x", pnote->descdata[i] & 0xff);
14945         printf ("\n");
14946       }
14947       break;
14948
14949     case NT_GNU_ABI_TAG:
14950       {
14951         unsigned long os, major, minor, subminor;
14952         const char *osname;
14953
14954         /* PR 17531: file: 030-599401-0.004.  */
14955         if (pnote->descsz < 16)
14956           {
14957             printf (_("    <corrupt GNU_ABI_TAG>\n"));
14958             break;
14959           }
14960
14961         os = byte_get ((unsigned char *) pnote->descdata, 4);
14962         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14963         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14964         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14965
14966         switch (os)
14967           {
14968           case GNU_ABI_TAG_LINUX:
14969             osname = "Linux";
14970             break;
14971           case GNU_ABI_TAG_HURD:
14972             osname = "Hurd";
14973             break;
14974           case GNU_ABI_TAG_SOLARIS:
14975             osname = "Solaris";
14976             break;
14977           case GNU_ABI_TAG_FREEBSD:
14978             osname = "FreeBSD";
14979             break;
14980           case GNU_ABI_TAG_NETBSD:
14981             osname = "NetBSD";
14982             break;
14983           default:
14984             osname = "Unknown";
14985             break;
14986           }
14987
14988         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14989                 major, minor, subminor);
14990       }
14991       break;
14992
14993     case NT_GNU_GOLD_VERSION:
14994       {
14995         unsigned long i;
14996
14997         printf (_("    Version: "));
14998         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14999           printf ("%c", pnote->descdata[i]);
15000         printf ("\n");
15001       }
15002       break;
15003     }
15004
15005   return 1;
15006 }
15007
15008 static const char *
15009 get_v850_elf_note_type (enum v850_notes n_type)
15010 {
15011   static char buff[64];
15012
15013   switch (n_type)
15014     {
15015     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15016     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15017     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15018     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15019     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15020     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15021     default:
15022       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15023       return buff;
15024     }
15025 }
15026
15027 static int
15028 print_v850_note (Elf_Internal_Note * pnote)
15029 {
15030   unsigned int val;
15031
15032   if (pnote->descsz != 4)
15033     return 0;
15034   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15035
15036   if (val == 0)
15037     {
15038       printf (_("not set\n"));
15039       return 1;
15040     }
15041
15042   switch (pnote->type)
15043     {
15044     case V850_NOTE_ALIGNMENT:
15045       switch (val)
15046         {
15047         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15048         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15049         }
15050       break;
15051
15052     case V850_NOTE_DATA_SIZE:
15053       switch (val)
15054         {
15055         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15056         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15057         }
15058       break;
15059
15060     case V850_NOTE_FPU_INFO:
15061       switch (val)
15062         {
15063         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15064         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15065         }
15066       break;
15067
15068     case V850_NOTE_MMU_INFO:
15069     case V850_NOTE_CACHE_INFO:
15070     case V850_NOTE_SIMD_INFO:
15071       if (val == EF_RH850_SIMD)
15072         {
15073           printf (_("yes\n"));
15074           return 1;
15075         }
15076       break;
15077
15078     default:
15079       /* An 'unknown note type' message will already have been displayed.  */
15080       break;
15081     }
15082
15083   printf (_("unknown value: %x\n"), val);
15084   return 0;
15085 }
15086
15087 static const char *
15088 get_netbsd_elfcore_note_type (unsigned e_type)
15089 {
15090   static char buff[64];
15091
15092   if (e_type == NT_NETBSDCORE_PROCINFO)
15093     {
15094       /* NetBSD core "procinfo" structure.  */
15095       return _("NetBSD procinfo structure");
15096     }
15097
15098   /* As of Jan 2002 there are no other machine-independent notes
15099      defined for NetBSD core files.  If the note type is less
15100      than the start of the machine-dependent note types, we don't
15101      understand it.  */
15102
15103   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15104     {
15105       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15106       return buff;
15107     }
15108
15109   switch (elf_header.e_machine)
15110     {
15111     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15112        and PT_GETFPREGS == mach+2.  */
15113
15114     case EM_OLD_ALPHA:
15115     case EM_ALPHA:
15116     case EM_SPARC:
15117     case EM_SPARC32PLUS:
15118     case EM_SPARCV9:
15119       switch (e_type)
15120         {
15121         case NT_NETBSDCORE_FIRSTMACH + 0:
15122           return _("PT_GETREGS (reg structure)");
15123         case NT_NETBSDCORE_FIRSTMACH + 2:
15124           return _("PT_GETFPREGS (fpreg structure)");
15125         default:
15126           break;
15127         }
15128       break;
15129
15130     /* On all other arch's, PT_GETREGS == mach+1 and
15131        PT_GETFPREGS == mach+3.  */
15132     default:
15133       switch (e_type)
15134         {
15135         case NT_NETBSDCORE_FIRSTMACH + 1:
15136           return _("PT_GETREGS (reg structure)");
15137         case NT_NETBSDCORE_FIRSTMACH + 3:
15138           return _("PT_GETFPREGS (fpreg structure)");
15139         default:
15140           break;
15141         }
15142     }
15143
15144   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15145             e_type - NT_NETBSDCORE_FIRSTMACH);
15146   return buff;
15147 }
15148
15149 static const char *
15150 get_stapsdt_note_type (unsigned e_type)
15151 {
15152   static char buff[64];
15153
15154   switch (e_type)
15155     {
15156     case NT_STAPSDT:
15157       return _("NT_STAPSDT (SystemTap probe descriptors)");
15158
15159     default:
15160       break;
15161     }
15162
15163   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15164   return buff;
15165 }
15166
15167 static int
15168 print_stapsdt_note (Elf_Internal_Note *pnote)
15169 {
15170   int addr_size = is_32bit_elf ? 4 : 8;
15171   char *data = pnote->descdata;
15172   char *data_end = pnote->descdata + pnote->descsz;
15173   bfd_vma pc, base_addr, semaphore;
15174   char *provider, *probe, *arg_fmt;
15175
15176   pc = byte_get ((unsigned char *) data, addr_size);
15177   data += addr_size;
15178   base_addr = byte_get ((unsigned char *) data, addr_size);
15179   data += addr_size;
15180   semaphore = byte_get ((unsigned char *) data, addr_size);
15181   data += addr_size;
15182
15183   provider = data;
15184   data += strlen (data) + 1;
15185   probe = data;
15186   data += strlen (data) + 1;
15187   arg_fmt = data;
15188   data += strlen (data) + 1;
15189
15190   printf (_("    Provider: %s\n"), provider);
15191   printf (_("    Name: %s\n"), probe);
15192   printf (_("    Location: "));
15193   print_vma (pc, FULL_HEX);
15194   printf (_(", Base: "));
15195   print_vma (base_addr, FULL_HEX);
15196   printf (_(", Semaphore: "));
15197   print_vma (semaphore, FULL_HEX);
15198   printf ("\n");
15199   printf (_("    Arguments: %s\n"), arg_fmt);
15200
15201   return data == data_end;
15202 }
15203
15204 static const char *
15205 get_ia64_vms_note_type (unsigned e_type)
15206 {
15207   static char buff[64];
15208
15209   switch (e_type)
15210     {
15211     case NT_VMS_MHD:
15212       return _("NT_VMS_MHD (module header)");
15213     case NT_VMS_LNM:
15214       return _("NT_VMS_LNM (language name)");
15215     case NT_VMS_SRC:
15216       return _("NT_VMS_SRC (source files)");
15217     case NT_VMS_TITLE:
15218       return "NT_VMS_TITLE";
15219     case NT_VMS_EIDC:
15220       return _("NT_VMS_EIDC (consistency check)");
15221     case NT_VMS_FPMODE:
15222       return _("NT_VMS_FPMODE (FP mode)");
15223     case NT_VMS_LINKTIME:
15224       return "NT_VMS_LINKTIME";
15225     case NT_VMS_IMGNAM:
15226       return _("NT_VMS_IMGNAM (image name)");
15227     case NT_VMS_IMGID:
15228       return _("NT_VMS_IMGID (image id)");
15229     case NT_VMS_LINKID:
15230       return _("NT_VMS_LINKID (link id)");
15231     case NT_VMS_IMGBID:
15232       return _("NT_VMS_IMGBID (build id)");
15233     case NT_VMS_GSTNAM:
15234       return _("NT_VMS_GSTNAM (sym table name)");
15235     case NT_VMS_ORIG_DYN:
15236       return "NT_VMS_ORIG_DYN";
15237     case NT_VMS_PATCHTIME:
15238       return "NT_VMS_PATCHTIME";
15239     default:
15240       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15241       return buff;
15242     }
15243 }
15244
15245 static int
15246 print_ia64_vms_note (Elf_Internal_Note * pnote)
15247 {
15248   switch (pnote->type)
15249     {
15250     case NT_VMS_MHD:
15251       if (pnote->descsz > 36)
15252         {
15253           size_t l = strlen (pnote->descdata + 34);
15254           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15255           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15256           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15257           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15258         }
15259       else
15260         printf (_("    Invalid size\n"));
15261       break;
15262     case NT_VMS_LNM:
15263       printf (_("   Language: %s\n"), pnote->descdata);
15264       break;
15265 #ifdef BFD64
15266     case NT_VMS_FPMODE:
15267       printf (_("   Floating Point mode: "));
15268       printf ("0x%016" BFD_VMA_FMT "x\n",
15269               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15270       break;
15271     case NT_VMS_LINKTIME:
15272       printf (_("   Link time: "));
15273       print_vms_time
15274         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15275       printf ("\n");
15276       break;
15277     case NT_VMS_PATCHTIME:
15278       printf (_("   Patch time: "));
15279       print_vms_time
15280         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15281       printf ("\n");
15282       break;
15283     case NT_VMS_ORIG_DYN:
15284       printf (_("   Major id: %u,  minor id: %u\n"),
15285               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15286               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15287       printf (_("   Last modified  : "));
15288       print_vms_time
15289         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15290       printf (_("\n   Link flags  : "));
15291       printf ("0x%016" BFD_VMA_FMT "x\n",
15292               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15293       printf (_("   Header flags: 0x%08x\n"),
15294               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15295       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15296       break;
15297 #endif
15298     case NT_VMS_IMGNAM:
15299       printf (_("    Image name: %s\n"), pnote->descdata);
15300       break;
15301     case NT_VMS_GSTNAM:
15302       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15303       break;
15304     case NT_VMS_IMGID:
15305       printf (_("    Image id: %s\n"), pnote->descdata);
15306       break;
15307     case NT_VMS_LINKID:
15308       printf (_("    Linker id: %s\n"), pnote->descdata);
15309       break;
15310     default:
15311       break;
15312     }
15313   return 1;
15314 }
15315
15316 /* Note that by the ELF standard, the name field is already null byte
15317    terminated, and namesz includes the terminating null byte.
15318    I.E. the value of namesz for the name "FSF" is 4.
15319
15320    If the value of namesz is zero, there is no name present.  */
15321 static int
15322 process_note (Elf_Internal_Note * pnote)
15323 {
15324   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15325   const char * nt;
15326
15327   if (pnote->namesz == 0)
15328     /* If there is no note name, then use the default set of
15329        note type strings.  */
15330     nt = get_note_type (pnote->type);
15331
15332   else if (const_strneq (pnote->namedata, "GNU"))
15333     /* GNU-specific object file notes.  */
15334     nt = get_gnu_elf_note_type (pnote->type);
15335
15336   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15337     /* NetBSD-specific core file notes.  */
15338     nt = get_netbsd_elfcore_note_type (pnote->type);
15339
15340   else if (strneq (pnote->namedata, "SPU/", 4))
15341     {
15342       /* SPU-specific core file notes.  */
15343       nt = pnote->namedata + 4;
15344       name = "SPU";
15345     }
15346
15347   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15348     /* VMS/ia64-specific file notes.  */
15349     nt = get_ia64_vms_note_type (pnote->type);
15350
15351   else if (const_strneq (pnote->namedata, "stapsdt"))
15352     nt = get_stapsdt_note_type (pnote->type);
15353
15354   else
15355     /* Don't recognize this note name; just use the default set of
15356        note type strings.  */
15357     nt = get_note_type (pnote->type);
15358
15359   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15360
15361   if (const_strneq (pnote->namedata, "IPF/VMS"))
15362     return print_ia64_vms_note (pnote);
15363   else if (const_strneq (pnote->namedata, "GNU"))
15364     return print_gnu_note (pnote);
15365   else if (const_strneq (pnote->namedata, "stapsdt"))
15366     return print_stapsdt_note (pnote);
15367   else if (const_strneq (pnote->namedata, "CORE"))
15368     return print_core_note (pnote);
15369   else
15370     return 1;
15371 }
15372
15373
15374 static int
15375 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15376 {
15377   Elf_External_Note * pnotes;
15378   Elf_External_Note * external;
15379   char * end;
15380   int res = 1;
15381
15382   if (length <= 0)
15383     return 0;
15384
15385   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15386                                            _("notes"));
15387   if (pnotes == NULL)
15388     return 0;
15389
15390   external = pnotes;
15391
15392   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15393           (unsigned long) offset, (unsigned long) length);
15394   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15395
15396   end = (char *) pnotes + length;
15397   while ((char *) external < end)
15398     {
15399       Elf_Internal_Note inote;
15400       size_t min_notesz;
15401       char *next;
15402       char * temp = NULL;
15403       size_t data_remaining = end - (char *) external;
15404
15405       if (!is_ia64_vms ())
15406         {
15407           /* PR binutils/15191
15408              Make sure that there is enough data to read.  */
15409           min_notesz = offsetof (Elf_External_Note, name);
15410           if (data_remaining < min_notesz)
15411             {
15412               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15413                     (int) data_remaining);
15414               break;
15415             }
15416           inote.type     = BYTE_GET (external->type);
15417           inote.namesz   = BYTE_GET (external->namesz);
15418           inote.namedata = external->name;
15419           inote.descsz   = BYTE_GET (external->descsz);
15420           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15421           /* PR 17531: file: 3443835e.  */
15422           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15423             {
15424               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15425               inote.descdata = inote.namedata;
15426               inote.namesz   = 0;
15427             }
15428
15429           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15430           next = inote.descdata + align_power (inote.descsz, 2);
15431         }
15432       else
15433         {
15434           Elf64_External_VMS_Note *vms_external;
15435
15436           /* PR binutils/15191
15437              Make sure that there is enough data to read.  */
15438           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15439           if (data_remaining < min_notesz)
15440             {
15441               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15442                     (int) data_remaining);
15443               break;
15444             }
15445
15446           vms_external = (Elf64_External_VMS_Note *) external;
15447           inote.type     = BYTE_GET (vms_external->type);
15448           inote.namesz   = BYTE_GET (vms_external->namesz);
15449           inote.namedata = vms_external->name;
15450           inote.descsz   = BYTE_GET (vms_external->descsz);
15451           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15452           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15453           next = inote.descdata + align_power (inote.descsz, 3);
15454         }
15455
15456       if (inote.descdata < (char *) external + min_notesz
15457           || next < (char *) external + min_notesz
15458           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15459           || inote.namedata + inote.namesz < inote.namedata
15460           || inote.descdata + inote.descsz < inote.descdata
15461           || data_remaining < (size_t)(next - (char *) external))
15462         {
15463           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15464                 (unsigned long) ((char *) external - (char *) pnotes));
15465           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15466                 inote.type, inote.namesz, inote.descsz);
15467           break;
15468         }
15469
15470       external = (Elf_External_Note *) next;
15471
15472       /* Verify that name is null terminated.  It appears that at least
15473          one version of Linux (RedHat 6.0) generates corefiles that don't
15474          comply with the ELF spec by failing to include the null byte in
15475          namesz.  */
15476       if (inote.namedata[inote.namesz - 1] != '\0')
15477         {
15478           temp = (char *) malloc (inote.namesz + 1);
15479           if (temp == NULL)
15480             {
15481               error (_("Out of memory allocating space for inote name\n"));
15482               res = 0;
15483               break;
15484             }
15485
15486           strncpy (temp, inote.namedata, inote.namesz);
15487           temp[inote.namesz] = 0;
15488
15489           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15490           inote.namedata = temp;
15491         }
15492
15493       res &= process_note (& inote);
15494
15495       if (temp != NULL)
15496         {
15497           free (temp);
15498           temp = NULL;
15499         }
15500     }
15501
15502   free (pnotes);
15503
15504   return res;
15505 }
15506
15507 static int
15508 process_corefile_note_segments (FILE * file)
15509 {
15510   Elf_Internal_Phdr * segment;
15511   unsigned int i;
15512   int res = 1;
15513
15514   if (! get_program_headers (file))
15515       return 0;
15516
15517   for (i = 0, segment = program_headers;
15518        i < elf_header.e_phnum;
15519        i++, segment++)
15520     {
15521       if (segment->p_type == PT_NOTE)
15522         res &= process_corefile_note_segment (file,
15523                                               (bfd_vma) segment->p_offset,
15524                                               (bfd_vma) segment->p_filesz);
15525     }
15526
15527   return res;
15528 }
15529
15530 static int
15531 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15532 {
15533   Elf_External_Note * pnotes;
15534   Elf_External_Note * external;
15535   char * end;
15536   int res = 1;
15537
15538   if (length <= 0)
15539     return 0;
15540
15541   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15542                                            _("v850 notes"));
15543   if (pnotes == NULL)
15544     return 0;
15545
15546   external = pnotes;
15547   end = (char*) pnotes + length;
15548
15549   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15550           (unsigned long) offset, (unsigned long) length);
15551
15552   while ((char *) external + sizeof (Elf_External_Note) < end)
15553     {
15554       Elf_External_Note * next;
15555       Elf_Internal_Note inote;
15556
15557       inote.type     = BYTE_GET (external->type);
15558       inote.namesz   = BYTE_GET (external->namesz);
15559       inote.namedata = external->name;
15560       inote.descsz   = BYTE_GET (external->descsz);
15561       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15562       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15563
15564       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15565         {
15566           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15567           inote.descdata = inote.namedata;
15568           inote.namesz   = 0;
15569         }
15570
15571       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15572
15573       if (   ((char *) next > end)
15574           || ((char *) next <  (char *) pnotes))
15575         {
15576           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15577                 (unsigned long) ((char *) external - (char *) pnotes));
15578           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15579                 inote.type, inote.namesz, inote.descsz);
15580           break;
15581         }
15582
15583       external = next;
15584
15585       /* Prevent out-of-bounds indexing.  */
15586       if (   inote.namedata + inote.namesz > end
15587           || inote.namedata + inote.namesz < inote.namedata)
15588         {
15589           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15590                 (unsigned long) ((char *) external - (char *) pnotes));
15591           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15592                 inote.type, inote.namesz, inote.descsz);
15593           break;
15594         }
15595
15596       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15597
15598       if (! print_v850_note (& inote))
15599         {
15600           res = 0;
15601           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15602                   inote.namesz, inote.descsz);
15603         }
15604     }
15605
15606   free (pnotes);
15607
15608   return res;
15609 }
15610
15611 static int
15612 process_note_sections (FILE * file)
15613 {
15614   Elf_Internal_Shdr * section;
15615   unsigned long i;
15616   int n = 0;
15617   int res = 1;
15618
15619   for (i = 0, section = section_headers;
15620        i < elf_header.e_shnum && section != NULL;
15621        i++, section++)
15622     {
15623       if (section->sh_type == SHT_NOTE)
15624         {
15625           res &= process_corefile_note_segment (file,
15626                                                 (bfd_vma) section->sh_offset,
15627                                                 (bfd_vma) section->sh_size);
15628           n++;
15629         }
15630
15631       if ((   elf_header.e_machine == EM_V800
15632            || elf_header.e_machine == EM_V850
15633            || elf_header.e_machine == EM_CYGNUS_V850)
15634           && section->sh_type == SHT_RENESAS_INFO)
15635         {
15636           res &= process_v850_notes (file,
15637                                      (bfd_vma) section->sh_offset,
15638                                      (bfd_vma) section->sh_size);
15639           n++;
15640         }
15641     }
15642
15643   if (n == 0)
15644     /* Try processing NOTE segments instead.  */
15645     return process_corefile_note_segments (file);
15646
15647   return res;
15648 }
15649
15650 static int
15651 process_notes (FILE * file)
15652 {
15653   /* If we have not been asked to display the notes then do nothing.  */
15654   if (! do_notes)
15655     return 1;
15656
15657   if (elf_header.e_type != ET_CORE)
15658     return process_note_sections (file);
15659
15660   /* No program headers means no NOTE segment.  */
15661   if (elf_header.e_phnum > 0)
15662     return process_corefile_note_segments (file);
15663
15664   printf (_("No note segments present in the core file.\n"));
15665   return 1;
15666 }
15667
15668 static int
15669 process_arch_specific (FILE * file)
15670 {
15671   if (! do_arch)
15672     return 1;
15673
15674   switch (elf_header.e_machine)
15675     {
15676     case EM_ARM:
15677       return process_arm_specific (file);
15678     case EM_MIPS:
15679     case EM_MIPS_RS3_LE:
15680       return process_mips_specific (file);
15681       break;
15682     case EM_NDS32:
15683       return process_nds32_specific (file);
15684       break;
15685     case EM_PPC:
15686       return process_power_specific (file);
15687       break;
15688     case EM_S390:
15689     case EM_S390_OLD:
15690       return process_s390_specific (file);
15691       break;
15692     case EM_SPARC:
15693     case EM_SPARC32PLUS:
15694     case EM_SPARCV9:
15695       return process_sparc_specific (file);
15696       break;
15697     case EM_TI_C6000:
15698       return process_tic6x_specific (file);
15699       break;
15700     case EM_MSP430:
15701       return process_msp430x_specific (file);
15702     default:
15703       break;
15704     }
15705   return 1;
15706 }
15707
15708 static int
15709 get_file_header (FILE * file)
15710 {
15711   /* Read in the identity array.  */
15712   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15713     return 0;
15714
15715   /* Determine how to read the rest of the header.  */
15716   switch (elf_header.e_ident[EI_DATA])
15717     {
15718     default: /* fall through */
15719     case ELFDATANONE: /* fall through */
15720     case ELFDATA2LSB:
15721       byte_get = byte_get_little_endian;
15722       byte_put = byte_put_little_endian;
15723       break;
15724     case ELFDATA2MSB:
15725       byte_get = byte_get_big_endian;
15726       byte_put = byte_put_big_endian;
15727       break;
15728     }
15729
15730   /* For now we only support 32 bit and 64 bit ELF files.  */
15731   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15732
15733   /* Read in the rest of the header.  */
15734   if (is_32bit_elf)
15735     {
15736       Elf32_External_Ehdr ehdr32;
15737
15738       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15739         return 0;
15740
15741       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15742       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15743       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15744       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15745       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15746       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15747       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15748       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15749       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15750       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15751       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15752       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15753       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15754     }
15755   else
15756     {
15757       Elf64_External_Ehdr ehdr64;
15758
15759       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15760          we will not be able to cope with the 64bit data found in
15761          64 ELF files.  Detect this now and abort before we start
15762          overwriting things.  */
15763       if (sizeof (bfd_vma) < 8)
15764         {
15765           error (_("This instance of readelf has been built without support for a\n\
15766 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15767           return 0;
15768         }
15769
15770       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15771         return 0;
15772
15773       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15774       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15775       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15776       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15777       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15778       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15779       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15780       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15781       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15782       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15783       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15784       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15785       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15786     }
15787
15788   if (elf_header.e_shoff)
15789     {
15790       /* There may be some extensions in the first section header.  Don't
15791          bomb if we can't read it.  */
15792       if (is_32bit_elf)
15793         get_32bit_section_headers (file, TRUE);
15794       else
15795         get_64bit_section_headers (file, TRUE);
15796     }
15797
15798   return 1;
15799 }
15800
15801 /* Process one ELF object file according to the command line options.
15802    This file may actually be stored in an archive.  The file is
15803    positioned at the start of the ELF object.  */
15804
15805 static int
15806 process_object (char * file_name, FILE * file)
15807 {
15808   unsigned int i;
15809
15810   if (! get_file_header (file))
15811     {
15812       error (_("%s: Failed to read file header\n"), file_name);
15813       return 1;
15814     }
15815
15816   /* Initialise per file variables.  */
15817   for (i = ARRAY_SIZE (version_info); i--;)
15818     version_info[i] = 0;
15819
15820   for (i = ARRAY_SIZE (dynamic_info); i--;)
15821     dynamic_info[i] = 0;
15822   dynamic_info_DT_GNU_HASH = 0;
15823
15824   /* Process the file.  */
15825   if (show_name)
15826     printf (_("\nFile: %s\n"), file_name);
15827
15828   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15829      Note we do this even if cmdline_dump_sects is empty because we
15830      must make sure that the dump_sets array is zeroed out before each
15831      object file is processed.  */
15832   if (num_dump_sects > num_cmdline_dump_sects)
15833     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15834
15835   if (num_cmdline_dump_sects > 0)
15836     {
15837       if (num_dump_sects == 0)
15838         /* A sneaky way of allocating the dump_sects array.  */
15839         request_dump_bynumber (num_cmdline_dump_sects, 0);
15840
15841       assert (num_dump_sects >= num_cmdline_dump_sects);
15842       memcpy (dump_sects, cmdline_dump_sects,
15843               num_cmdline_dump_sects * sizeof (* dump_sects));
15844     }
15845
15846   if (! process_file_header ())
15847     return 1;
15848
15849   if (! process_section_headers (file))
15850     {
15851       /* Without loaded section headers we cannot process lots of
15852          things.  */
15853       do_unwind = do_version = do_dump = do_arch = 0;
15854
15855       if (! do_using_dynamic)
15856         do_syms = do_dyn_syms = do_reloc = 0;
15857     }
15858
15859   if (! process_section_groups (file))
15860     {
15861       /* Without loaded section groups we cannot process unwind.  */
15862       do_unwind = 0;
15863     }
15864
15865   if (process_program_headers (file))
15866     process_dynamic_section (file);
15867
15868   process_relocs (file);
15869
15870   process_unwind (file);
15871
15872   process_symbol_table (file);
15873
15874   process_syminfo (file);
15875
15876   process_version_sections (file);
15877
15878   process_section_contents (file);
15879
15880   process_notes (file);
15881
15882   process_gnu_liblist (file);
15883
15884   process_arch_specific (file);
15885
15886   if (program_headers)
15887     {
15888       free (program_headers);
15889       program_headers = NULL;
15890     }
15891
15892   if (section_headers)
15893     {
15894       free (section_headers);
15895       section_headers = NULL;
15896     }
15897
15898   if (string_table)
15899     {
15900       free (string_table);
15901       string_table = NULL;
15902       string_table_length = 0;
15903     }
15904
15905   if (dynamic_strings)
15906     {
15907       free (dynamic_strings);
15908       dynamic_strings = NULL;
15909       dynamic_strings_length = 0;
15910     }
15911
15912   if (dynamic_symbols)
15913     {
15914       free (dynamic_symbols);
15915       dynamic_symbols = NULL;
15916       num_dynamic_syms = 0;
15917     }
15918
15919   if (dynamic_syminfo)
15920     {
15921       free (dynamic_syminfo);
15922       dynamic_syminfo = NULL;
15923     }
15924
15925   if (dynamic_section)
15926     {
15927       free (dynamic_section);
15928       dynamic_section = NULL;
15929     }
15930
15931   if (section_headers_groups)
15932     {
15933       free (section_headers_groups);
15934       section_headers_groups = NULL;
15935     }
15936
15937   if (section_groups)
15938     {
15939       struct group_list * g;
15940       struct group_list * next;
15941
15942       for (i = 0; i < group_count; i++)
15943         {
15944           for (g = section_groups [i].root; g != NULL; g = next)
15945             {
15946               next = g->next;
15947               free (g);
15948             }
15949         }
15950
15951       free (section_groups);
15952       section_groups = NULL;
15953     }
15954
15955   free_debug_memory ();
15956
15957   return 0;
15958 }
15959
15960 /* Process an ELF archive.
15961    On entry the file is positioned just after the ARMAG string.  */
15962
15963 static int
15964 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15965 {
15966   struct archive_info arch;
15967   struct archive_info nested_arch;
15968   size_t got;
15969   int ret;
15970
15971   show_name = 1;
15972
15973   /* The ARCH structure is used to hold information about this archive.  */
15974   arch.file_name = NULL;
15975   arch.file = NULL;
15976   arch.index_array = NULL;
15977   arch.sym_table = NULL;
15978   arch.longnames = NULL;
15979
15980   /* The NESTED_ARCH structure is used as a single-item cache of information
15981      about a nested archive (when members of a thin archive reside within
15982      another regular archive file).  */
15983   nested_arch.file_name = NULL;
15984   nested_arch.file = NULL;
15985   nested_arch.index_array = NULL;
15986   nested_arch.sym_table = NULL;
15987   nested_arch.longnames = NULL;
15988
15989   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15990     {
15991       ret = 1;
15992       goto out;
15993     }
15994
15995   if (do_archive_index)
15996     {
15997       if (arch.sym_table == NULL)
15998         error (_("%s: unable to dump the index as none was found\n"), file_name);
15999       else
16000         {
16001           unsigned long i, l;
16002           unsigned long current_pos;
16003
16004           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16005                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16006           current_pos = ftell (file);
16007
16008           for (i = l = 0; i < arch.index_num; i++)
16009             {
16010               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16011                 {
16012                   char * member_name;
16013
16014                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16015
16016                   if (member_name != NULL)
16017                     {
16018                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16019
16020                       if (qualified_name != NULL)
16021                         {
16022                           printf (_("Contents of binary %s at offset "), qualified_name);
16023                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16024                           putchar ('\n');
16025                           free (qualified_name);
16026                         }
16027                     }
16028                 }
16029
16030               if (l >= arch.sym_size)
16031                 {
16032                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16033                          file_name);
16034                   break;
16035                 }
16036               /* PR 17531: file: 0b6630b2.  */
16037               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16038               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16039             }
16040
16041           if (arch.uses_64bit_indicies)
16042             l = (l + 7) & ~ 7;
16043           else
16044             l += l & 1;
16045
16046           if (l < arch.sym_size)
16047             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16048                    file_name, arch.sym_size - l);
16049
16050           if (fseek (file, current_pos, SEEK_SET) != 0)
16051             {
16052               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16053               ret = 1;
16054               goto out;
16055             }
16056         }
16057
16058       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16059           && !do_segments && !do_header && !do_dump && !do_version
16060           && !do_histogram && !do_debugging && !do_arch && !do_notes
16061           && !do_section_groups && !do_dyn_syms)
16062         {
16063           ret = 0; /* Archive index only.  */
16064           goto out;
16065         }
16066     }
16067
16068   ret = 0;
16069
16070   while (1)
16071     {
16072       char * name;
16073       size_t namelen;
16074       char * qualified_name;
16075
16076       /* Read the next archive header.  */
16077       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16078         {
16079           error (_("%s: failed to seek to next archive header\n"), file_name);
16080           return 1;
16081         }
16082       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16083       if (got != sizeof arch.arhdr)
16084         {
16085           if (got == 0)
16086             break;
16087           error (_("%s: failed to read archive header\n"), file_name);
16088           ret = 1;
16089           break;
16090         }
16091       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16092         {
16093           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16094           ret = 1;
16095           break;
16096         }
16097
16098       arch.next_arhdr_offset += sizeof arch.arhdr;
16099
16100       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16101       if (archive_file_size & 01)
16102         ++archive_file_size;
16103
16104       name = get_archive_member_name (&arch, &nested_arch);
16105       if (name == NULL)
16106         {
16107           error (_("%s: bad archive file name\n"), file_name);
16108           ret = 1;
16109           break;
16110         }
16111       namelen = strlen (name);
16112
16113       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16114       if (qualified_name == NULL)
16115         {
16116           error (_("%s: bad archive file name\n"), file_name);
16117           ret = 1;
16118           break;
16119         }
16120
16121       if (is_thin_archive && arch.nested_member_origin == 0)
16122         {
16123           /* This is a proxy for an external member of a thin archive.  */
16124           FILE * member_file;
16125           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16126           if (member_file_name == NULL)
16127             {
16128               ret = 1;
16129               break;
16130             }
16131
16132           member_file = fopen (member_file_name, "rb");
16133           if (member_file == NULL)
16134             {
16135               error (_("Input file '%s' is not readable.\n"), member_file_name);
16136               free (member_file_name);
16137               ret = 1;
16138               break;
16139             }
16140
16141           archive_file_offset = arch.nested_member_origin;
16142
16143           ret |= process_object (qualified_name, member_file);
16144
16145           fclose (member_file);
16146           free (member_file_name);
16147         }
16148       else if (is_thin_archive)
16149         {
16150           /* PR 15140: Allow for corrupt thin archives.  */
16151           if (nested_arch.file == NULL)
16152             {
16153               error (_("%s: contains corrupt thin archive: %s\n"),
16154                      file_name, name);
16155               ret = 1;
16156               break;
16157             }
16158
16159           /* This is a proxy for a member of a nested archive.  */
16160           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16161
16162           /* The nested archive file will have been opened and setup by
16163              get_archive_member_name.  */
16164           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16165             {
16166               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16167               ret = 1;
16168               break;
16169             }
16170
16171           ret |= process_object (qualified_name, nested_arch.file);
16172         }
16173       else
16174         {
16175           archive_file_offset = arch.next_arhdr_offset;
16176           arch.next_arhdr_offset += archive_file_size;
16177
16178           ret |= process_object (qualified_name, file);
16179         }
16180
16181       if (dump_sects != NULL)
16182         {
16183           free (dump_sects);
16184           dump_sects = NULL;
16185           num_dump_sects = 0;
16186         }
16187
16188       free (qualified_name);
16189     }
16190
16191  out:
16192   if (nested_arch.file != NULL)
16193     fclose (nested_arch.file);
16194   release_archive (&nested_arch);
16195   release_archive (&arch);
16196
16197   return ret;
16198 }
16199
16200 static int
16201 process_file (char * file_name)
16202 {
16203   FILE * file;
16204   struct stat statbuf;
16205   char armag[SARMAG];
16206   int ret;
16207
16208   if (stat (file_name, &statbuf) < 0)
16209     {
16210       if (errno == ENOENT)
16211         error (_("'%s': No such file\n"), file_name);
16212       else
16213         error (_("Could not locate '%s'.  System error message: %s\n"),
16214                file_name, strerror (errno));
16215       return 1;
16216     }
16217
16218   if (! S_ISREG (statbuf.st_mode))
16219     {
16220       error (_("'%s' is not an ordinary file\n"), file_name);
16221       return 1;
16222     }
16223
16224   file = fopen (file_name, "rb");
16225   if (file == NULL)
16226     {
16227       error (_("Input file '%s' is not readable.\n"), file_name);
16228       return 1;
16229     }
16230
16231   if (fread (armag, SARMAG, 1, file) != 1)
16232     {
16233       error (_("%s: Failed to read file's magic number\n"), file_name);
16234       fclose (file);
16235       return 1;
16236     }
16237
16238   current_file_size = (bfd_size_type) statbuf.st_size;
16239
16240   if (memcmp (armag, ARMAG, SARMAG) == 0)
16241     ret = process_archive (file_name, file, FALSE);
16242   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16243     ret = process_archive (file_name, file, TRUE);
16244   else
16245     {
16246       if (do_archive_index)
16247         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16248                file_name);
16249
16250       rewind (file);
16251       archive_file_size = archive_file_offset = 0;
16252       ret = process_object (file_name, file);
16253     }
16254
16255   fclose (file);
16256
16257   current_file_size = 0;
16258   return ret;
16259 }
16260
16261 #ifdef SUPPORT_DISASSEMBLY
16262 /* Needed by the i386 disassembler.  For extra credit, someone could
16263    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16264    symbols.  */
16265
16266 void
16267 print_address (unsigned int addr, FILE * outfile)
16268 {
16269   fprintf (outfile,"0x%8.8x", addr);
16270 }
16271
16272 /* Needed by the i386 disassembler.  */
16273 void
16274 db_task_printsym (unsigned int addr)
16275 {
16276   print_address (addr, stderr);
16277 }
16278 #endif
16279
16280 int
16281 main (int argc, char ** argv)
16282 {
16283   int err;
16284
16285 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16286   setlocale (LC_MESSAGES, "");
16287 #endif
16288 #if defined (HAVE_SETLOCALE)
16289   setlocale (LC_CTYPE, "");
16290 #endif
16291   bindtextdomain (PACKAGE, LOCALEDIR);
16292   textdomain (PACKAGE);
16293
16294   expandargv (&argc, &argv);
16295
16296   parse_args (argc, argv);
16297
16298   if (num_dump_sects > 0)
16299     {
16300       /* Make a copy of the dump_sects array.  */
16301       cmdline_dump_sects = (dump_type *)
16302           malloc (num_dump_sects * sizeof (* dump_sects));
16303       if (cmdline_dump_sects == NULL)
16304         error (_("Out of memory allocating dump request table.\n"));
16305       else
16306         {
16307           memcpy (cmdline_dump_sects, dump_sects,
16308                   num_dump_sects * sizeof (* dump_sects));
16309           num_cmdline_dump_sects = num_dump_sects;
16310         }
16311     }
16312
16313   if (optind < (argc - 1))
16314     show_name = 1;
16315   else if (optind >= argc)
16316     {
16317       warn (_("Nothing to do.\n"));
16318       usage (stderr);
16319     }
16320
16321   err = 0;
16322   while (optind < argc)
16323     err |= process_file (argv[optind++]);
16324
16325   if (dump_sects != NULL)
16326     free (dump_sects);
16327   if (cmdline_dump_sects != NULL)
16328     free (cmdline_dump_sects);
16329
16330   return err;
16331 }