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_PPC:
2896           if (e_flags & EF_PPC_EMB)
2897             strcat (buf, ", emb");
2898
2899           if (e_flags & EF_PPC_RELOCATABLE)
2900             strcat (buf, _(", relocatable"));
2901
2902           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2903             strcat (buf, _(", relocatable-lib"));
2904           break;
2905
2906         case EM_PPC64:
2907           if (e_flags & EF_PPC64_ABI)
2908             {
2909               char abi[] = ", abiv0";
2910
2911               abi[6] += e_flags & EF_PPC64_ABI;
2912               strcat (buf, abi);
2913             }
2914           break;
2915
2916         case EM_V800:
2917           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2918             strcat (buf, ", RH850 ABI");
2919
2920           if (e_flags & EF_V800_850E3)
2921             strcat (buf, ", V3 architecture");
2922
2923           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2924             strcat (buf, ", FPU not used");
2925
2926           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2927             strcat (buf, ", regmode: COMMON");
2928
2929           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2930             strcat (buf, ", r4 not used");
2931
2932           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2933             strcat (buf, ", r30 not used");
2934
2935           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2936             strcat (buf, ", r5 not used");
2937
2938           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2939             strcat (buf, ", r2 not used");
2940
2941           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2942             {
2943               switch (e_flags & - e_flags)
2944                 {
2945                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2946                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2947                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2948                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2949                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2950                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2951                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2952                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2953                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2954                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2955                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2956                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2957                 default: break;
2958                 }
2959             }
2960           break;
2961
2962         case EM_V850:
2963         case EM_CYGNUS_V850:
2964           switch (e_flags & EF_V850_ARCH)
2965             {
2966             case E_V850E3V5_ARCH:
2967               strcat (buf, ", v850e3v5");
2968               break;
2969             case E_V850E2V3_ARCH:
2970               strcat (buf, ", v850e2v3");
2971               break;
2972             case E_V850E2_ARCH:
2973               strcat (buf, ", v850e2");
2974               break;
2975             case E_V850E1_ARCH:
2976               strcat (buf, ", v850e1");
2977               break;
2978             case E_V850E_ARCH:
2979               strcat (buf, ", v850e");
2980               break;
2981             case E_V850_ARCH:
2982               strcat (buf, ", v850");
2983               break;
2984             default:
2985               strcat (buf, _(", unknown v850 architecture variant"));
2986               break;
2987             }
2988           break;
2989
2990         case EM_M32R:
2991         case EM_CYGNUS_M32R:
2992           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2993             strcat (buf, ", m32r");
2994           break;
2995
2996         case EM_MIPS:
2997         case EM_MIPS_RS3_LE:
2998           if (e_flags & EF_MIPS_NOREORDER)
2999             strcat (buf, ", noreorder");
3000
3001           if (e_flags & EF_MIPS_PIC)
3002             strcat (buf, ", pic");
3003
3004           if (e_flags & EF_MIPS_CPIC)
3005             strcat (buf, ", cpic");
3006
3007           if (e_flags & EF_MIPS_UCODE)
3008             strcat (buf, ", ugen_reserved");
3009
3010           if (e_flags & EF_MIPS_ABI2)
3011             strcat (buf, ", abi2");
3012
3013           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3014             strcat (buf, ", odk first");
3015
3016           if (e_flags & EF_MIPS_32BITMODE)
3017             strcat (buf, ", 32bitmode");
3018
3019           if (e_flags & EF_MIPS_NAN2008)
3020             strcat (buf, ", nan2008");
3021
3022           if (e_flags & EF_MIPS_FP64)
3023             strcat (buf, ", fp64");
3024
3025           switch ((e_flags & EF_MIPS_MACH))
3026             {
3027             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3028             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3029             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3030             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3031             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3032             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3033             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3034             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3035             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3036             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3037             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3038             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3039             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3040             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3041             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3042             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3043             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3044             case 0:
3045             /* We simply ignore the field in this case to avoid confusion:
3046                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3047                extension.  */
3048               break;
3049             default: strcat (buf, _(", unknown CPU")); break;
3050             }
3051
3052           switch ((e_flags & EF_MIPS_ABI))
3053             {
3054             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3055             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3056             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3057             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3058             case 0:
3059             /* We simply ignore the field in this case to avoid confusion:
3060                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3061                This means it is likely to be an o32 file, but not for
3062                sure.  */
3063               break;
3064             default: strcat (buf, _(", unknown ABI")); break;
3065             }
3066
3067           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3068             strcat (buf, ", mdmx");
3069
3070           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3071             strcat (buf, ", mips16");
3072
3073           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3074             strcat (buf, ", micromips");
3075
3076           switch ((e_flags & EF_MIPS_ARCH))
3077             {
3078             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3079             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3080             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3081             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3082             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3083             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3084             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3085             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3086             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3087             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3088             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3089             default: strcat (buf, _(", unknown ISA")); break;
3090             }
3091           break;
3092
3093         case EM_NDS32:
3094           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3095           break;
3096
3097         case EM_SH:
3098           switch ((e_flags & EF_SH_MACH_MASK))
3099             {
3100             case EF_SH1: strcat (buf, ", sh1"); break;
3101             case EF_SH2: strcat (buf, ", sh2"); break;
3102             case EF_SH3: strcat (buf, ", sh3"); break;
3103             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3104             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3105             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3106             case EF_SH3E: strcat (buf, ", sh3e"); break;
3107             case EF_SH4: strcat (buf, ", sh4"); break;
3108             case EF_SH5: strcat (buf, ", sh5"); break;
3109             case EF_SH2E: strcat (buf, ", sh2e"); break;
3110             case EF_SH4A: strcat (buf, ", sh4a"); break;
3111             case EF_SH2A: strcat (buf, ", sh2a"); break;
3112             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3113             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3114             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3115             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3116             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3117             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3118             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3119             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3120             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3121             default: strcat (buf, _(", unknown ISA")); break;
3122             }
3123
3124           if (e_flags & EF_SH_PIC)
3125             strcat (buf, ", pic");
3126
3127           if (e_flags & EF_SH_FDPIC)
3128             strcat (buf, ", fdpic");
3129           break;
3130
3131         case EM_OR1K:
3132           if (e_flags & EF_OR1K_NODELAY)
3133             strcat (buf, ", no delay");
3134           break;
3135
3136         case EM_SPARCV9:
3137           if (e_flags & EF_SPARC_32PLUS)
3138             strcat (buf, ", v8+");
3139
3140           if (e_flags & EF_SPARC_SUN_US1)
3141             strcat (buf, ", ultrasparcI");
3142
3143           if (e_flags & EF_SPARC_SUN_US3)
3144             strcat (buf, ", ultrasparcIII");
3145
3146           if (e_flags & EF_SPARC_HAL_R1)
3147             strcat (buf, ", halr1");
3148
3149           if (e_flags & EF_SPARC_LEDATA)
3150             strcat (buf, ", ledata");
3151
3152           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3153             strcat (buf, ", tso");
3154
3155           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3156             strcat (buf, ", pso");
3157
3158           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3159             strcat (buf, ", rmo");
3160           break;
3161
3162         case EM_PARISC:
3163           switch (e_flags & EF_PARISC_ARCH)
3164             {
3165             case EFA_PARISC_1_0:
3166               strcpy (buf, ", PA-RISC 1.0");
3167               break;
3168             case EFA_PARISC_1_1:
3169               strcpy (buf, ", PA-RISC 1.1");
3170               break;
3171             case EFA_PARISC_2_0:
3172               strcpy (buf, ", PA-RISC 2.0");
3173               break;
3174             default:
3175               break;
3176             }
3177           if (e_flags & EF_PARISC_TRAPNIL)
3178             strcat (buf, ", trapnil");
3179           if (e_flags & EF_PARISC_EXT)
3180             strcat (buf, ", ext");
3181           if (e_flags & EF_PARISC_LSB)
3182             strcat (buf, ", lsb");
3183           if (e_flags & EF_PARISC_WIDE)
3184             strcat (buf, ", wide");
3185           if (e_flags & EF_PARISC_NO_KABP)
3186             strcat (buf, ", no kabp");
3187           if (e_flags & EF_PARISC_LAZYSWAP)
3188             strcat (buf, ", lazyswap");
3189           break;
3190
3191         case EM_PJ:
3192         case EM_PJ_OLD:
3193           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3194             strcat (buf, ", new calling convention");
3195
3196           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3197             strcat (buf, ", gnu calling convention");
3198           break;
3199
3200         case EM_IA_64:
3201           if ((e_flags & EF_IA_64_ABI64))
3202             strcat (buf, ", 64-bit");
3203           else
3204             strcat (buf, ", 32-bit");
3205           if ((e_flags & EF_IA_64_REDUCEDFP))
3206             strcat (buf, ", reduced fp model");
3207           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3208             strcat (buf, ", no function descriptors, constant gp");
3209           else if ((e_flags & EF_IA_64_CONS_GP))
3210             strcat (buf, ", constant gp");
3211           if ((e_flags & EF_IA_64_ABSOLUTE))
3212             strcat (buf, ", absolute");
3213           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3214             {
3215               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3216                 strcat (buf, ", vms_linkages");
3217               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3218                 {
3219                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3220                   break;
3221                 case EF_IA_64_VMS_COMCOD_WARNING:
3222                   strcat (buf, ", warning");
3223                   break;
3224                 case EF_IA_64_VMS_COMCOD_ERROR:
3225                   strcat (buf, ", error");
3226                   break;
3227                 case EF_IA_64_VMS_COMCOD_ABORT:
3228                   strcat (buf, ", abort");
3229                   break;
3230                 default:
3231                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3232                         e_flags & EF_IA_64_VMS_COMCOD);
3233                   strcat (buf, ", <unknown>");
3234                 }
3235             }
3236           break;
3237
3238         case EM_VAX:
3239           if ((e_flags & EF_VAX_NONPIC))
3240             strcat (buf, ", non-PIC");
3241           if ((e_flags & EF_VAX_DFLOAT))
3242             strcat (buf, ", D-Float");
3243           if ((e_flags & EF_VAX_GFLOAT))
3244             strcat (buf, ", G-Float");
3245           break;
3246
3247         case EM_VISIUM:
3248           if (e_flags & EF_VISIUM_ARCH_MCM)
3249             strcat (buf, ", mcm");
3250           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3251             strcat (buf, ", mcm24");
3252           if (e_flags & EF_VISIUM_ARCH_GR6)
3253             strcat (buf, ", gr6");
3254           break;
3255
3256         case EM_RL78:
3257           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3258             {
3259             case E_FLAG_RL78_ANY_CPU: break;
3260             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3261             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3262             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3263             }
3264           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3265             strcat (buf, ", 64-bit doubles");
3266           break;
3267
3268         case EM_RX:
3269           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3270             strcat (buf, ", 64-bit doubles");
3271           if (e_flags & E_FLAG_RX_DSP)
3272             strcat (buf, ", dsp");
3273           if (e_flags & E_FLAG_RX_PID)
3274             strcat (buf, ", pid");
3275           if (e_flags & E_FLAG_RX_ABI)
3276             strcat (buf, ", RX ABI");
3277           if (e_flags & E_FLAG_RX_SINSNS_SET)
3278             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3279                     ? ", uses String instructions" : ", bans String instructions");
3280           break;
3281
3282         case EM_S390:
3283           if (e_flags & EF_S390_HIGH_GPRS)
3284             strcat (buf, ", highgprs");
3285           break;
3286
3287         case EM_TI_C6000:
3288           if ((e_flags & EF_C6000_REL))
3289             strcat (buf, ", relocatable module");
3290           break;
3291
3292         case EM_MSP430:
3293           strcat (buf, _(": architecture variant: "));
3294           switch (e_flags & EF_MSP430_MACH)
3295             {
3296             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3297             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3298             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3299             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3300             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3301             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3302             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3303             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3304             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3305             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3306             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3307             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3308             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3309             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3310             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3311             default:
3312               strcat (buf, _(": unknown")); break;
3313             }
3314
3315           if (e_flags & ~ EF_MSP430_MACH)
3316             strcat (buf, _(": unknown extra flag bits also present"));
3317         }
3318     }
3319
3320   return buf;
3321 }
3322
3323 static const char *
3324 get_osabi_name (unsigned int osabi)
3325 {
3326   static char buff[32];
3327
3328   switch (osabi)
3329     {
3330     case ELFOSABI_NONE:         return "UNIX - System V";
3331     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3332     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3333     case ELFOSABI_GNU:          return "UNIX - GNU";
3334     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3335     case ELFOSABI_AIX:          return "UNIX - AIX";
3336     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3337     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3338     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3339     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3340     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3341     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3342     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3343     case ELFOSABI_AROS:         return "AROS";
3344     case ELFOSABI_FENIXOS:      return "FenixOS";
3345     default:
3346       if (osabi >= 64)
3347         switch (elf_header.e_machine)
3348           {
3349           case EM_ARM:
3350             switch (osabi)
3351               {
3352               case ELFOSABI_ARM:        return "ARM";
3353               default:
3354                 break;
3355               }
3356             break;
3357
3358           case EM_MSP430:
3359           case EM_MSP430_OLD:
3360           case EM_VISIUM:
3361             switch (osabi)
3362               {
3363               case ELFOSABI_STANDALONE: return _("Standalone App");
3364               default:
3365                 break;
3366               }
3367             break;
3368
3369           case EM_TI_C6000:
3370             switch (osabi)
3371               {
3372               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3373               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3374               default:
3375                 break;
3376               }
3377             break;
3378
3379           default:
3380             break;
3381           }
3382       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3383       return buff;
3384     }
3385 }
3386
3387 static const char *
3388 get_aarch64_segment_type (unsigned long type)
3389 {
3390   switch (type)
3391     {
3392     case PT_AARCH64_ARCHEXT:
3393       return "AARCH64_ARCHEXT";
3394     default:
3395       break;
3396     }
3397
3398   return NULL;
3399 }
3400
3401 static const char *
3402 get_arm_segment_type (unsigned long type)
3403 {
3404   switch (type)
3405     {
3406     case PT_ARM_EXIDX:
3407       return "EXIDX";
3408     default:
3409       break;
3410     }
3411
3412   return NULL;
3413 }
3414
3415 static const char *
3416 get_mips_segment_type (unsigned long type)
3417 {
3418   switch (type)
3419     {
3420     case PT_MIPS_REGINFO:
3421       return "REGINFO";
3422     case PT_MIPS_RTPROC:
3423       return "RTPROC";
3424     case PT_MIPS_OPTIONS:
3425       return "OPTIONS";
3426     case PT_MIPS_ABIFLAGS:
3427       return "ABIFLAGS";
3428     default:
3429       break;
3430     }
3431
3432   return NULL;
3433 }
3434
3435 static const char *
3436 get_parisc_segment_type (unsigned long type)
3437 {
3438   switch (type)
3439     {
3440     case PT_HP_TLS:             return "HP_TLS";
3441     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3442     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3443     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3444     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3445     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3446     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3447     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3448     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3449     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3450     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3451     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3452     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3453     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3454     case PT_HP_STACK:           return "HP_STACK";
3455     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3456     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3457     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3458     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3459     default:
3460       break;
3461     }
3462
3463   return NULL;
3464 }
3465
3466 static const char *
3467 get_ia64_segment_type (unsigned long type)
3468 {
3469   switch (type)
3470     {
3471     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3472     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3473     case PT_HP_TLS:             return "HP_TLS";
3474     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3475     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3476     case PT_IA_64_HP_STACK:     return "HP_STACK";
3477     default:
3478       break;
3479     }
3480
3481   return NULL;
3482 }
3483
3484 static const char *
3485 get_tic6x_segment_type (unsigned long type)
3486 {
3487   switch (type)
3488     {
3489     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3490     default:
3491       break;
3492     }
3493
3494   return NULL;
3495 }
3496
3497 static const char *
3498 get_segment_type (unsigned long p_type)
3499 {
3500   static char buff[32];
3501
3502   switch (p_type)
3503     {
3504     case PT_NULL:       return "NULL";
3505     case PT_LOAD:       return "LOAD";
3506     case PT_DYNAMIC:    return "DYNAMIC";
3507     case PT_INTERP:     return "INTERP";
3508     case PT_NOTE:       return "NOTE";
3509     case PT_SHLIB:      return "SHLIB";
3510     case PT_PHDR:       return "PHDR";
3511     case PT_TLS:        return "TLS";
3512
3513     case PT_GNU_EH_FRAME:
3514                         return "GNU_EH_FRAME";
3515     case PT_GNU_STACK:  return "GNU_STACK";
3516     case PT_GNU_RELRO:  return "GNU_RELRO";
3517
3518     default:
3519       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3520         {
3521           const char * result;
3522
3523           switch (elf_header.e_machine)
3524             {
3525             case EM_AARCH64:
3526               result = get_aarch64_segment_type (p_type);
3527               break;
3528             case EM_ARM:
3529               result = get_arm_segment_type (p_type);
3530               break;
3531             case EM_MIPS:
3532             case EM_MIPS_RS3_LE:
3533               result = get_mips_segment_type (p_type);
3534               break;
3535             case EM_PARISC:
3536               result = get_parisc_segment_type (p_type);
3537               break;
3538             case EM_IA_64:
3539               result = get_ia64_segment_type (p_type);
3540               break;
3541             case EM_TI_C6000:
3542               result = get_tic6x_segment_type (p_type);
3543               break;
3544             default:
3545               result = NULL;
3546               break;
3547             }
3548
3549           if (result != NULL)
3550             return result;
3551
3552           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3553         }
3554       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3555         {
3556           const char * result;
3557
3558           switch (elf_header.e_machine)
3559             {
3560             case EM_PARISC:
3561               result = get_parisc_segment_type (p_type);
3562               break;
3563             case EM_IA_64:
3564               result = get_ia64_segment_type (p_type);
3565               break;
3566             default:
3567               result = NULL;
3568               break;
3569             }
3570
3571           if (result != NULL)
3572             return result;
3573
3574           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3575         }
3576       else
3577         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3578
3579       return buff;
3580     }
3581 }
3582
3583 static const char *
3584 get_mips_section_type_name (unsigned int sh_type)
3585 {
3586   switch (sh_type)
3587     {
3588     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3589     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3590     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3591     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3592     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3593     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3594     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3595     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3596     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3597     case SHT_MIPS_RELD:          return "MIPS_RELD";
3598     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3599     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3600     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3601     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3602     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3603     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3604     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3605     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3606     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3607     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3608     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3609     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3610     case SHT_MIPS_LINE:          return "MIPS_LINE";
3611     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3612     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3613     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3614     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3615     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3616     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3617     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3618     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3619     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3620     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3621     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3622     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3623     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3624     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3625     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3626     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3627     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3628     default:
3629       break;
3630     }
3631   return NULL;
3632 }
3633
3634 static const char *
3635 get_parisc_section_type_name (unsigned int sh_type)
3636 {
3637   switch (sh_type)
3638     {
3639     case SHT_PARISC_EXT:        return "PARISC_EXT";
3640     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3641     case SHT_PARISC_DOC:        return "PARISC_DOC";
3642     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3643     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3644     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3645     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3646     default:
3647       break;
3648     }
3649   return NULL;
3650 }
3651
3652 static const char *
3653 get_ia64_section_type_name (unsigned int sh_type)
3654 {
3655   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3656   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3657     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3658
3659   switch (sh_type)
3660     {
3661     case SHT_IA_64_EXT:                return "IA_64_EXT";
3662     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3663     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3664     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3665     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3666     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3667     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3668     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3669     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3670     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3671     default:
3672       break;
3673     }
3674   return NULL;
3675 }
3676
3677 static const char *
3678 get_x86_64_section_type_name (unsigned int sh_type)
3679 {
3680   switch (sh_type)
3681     {
3682     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3683     default:
3684       break;
3685     }
3686   return NULL;
3687 }
3688
3689 static const char *
3690 get_aarch64_section_type_name (unsigned int sh_type)
3691 {
3692   switch (sh_type)
3693     {
3694     case SHT_AARCH64_ATTRIBUTES:
3695       return "AARCH64_ATTRIBUTES";
3696     default:
3697       break;
3698     }
3699   return NULL;
3700 }
3701
3702 static const char *
3703 get_arm_section_type_name (unsigned int sh_type)
3704 {
3705   switch (sh_type)
3706     {
3707     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3708     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3709     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3710     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3711     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3712     default:
3713       break;
3714     }
3715   return NULL;
3716 }
3717
3718 static const char *
3719 get_tic6x_section_type_name (unsigned int sh_type)
3720 {
3721   switch (sh_type)
3722     {
3723     case SHT_C6000_UNWIND:
3724       return "C6000_UNWIND";
3725     case SHT_C6000_PREEMPTMAP:
3726       return "C6000_PREEMPTMAP";
3727     case SHT_C6000_ATTRIBUTES:
3728       return "C6000_ATTRIBUTES";
3729     case SHT_TI_ICODE:
3730       return "TI_ICODE";
3731     case SHT_TI_XREF:
3732       return "TI_XREF";
3733     case SHT_TI_HANDLER:
3734       return "TI_HANDLER";
3735     case SHT_TI_INITINFO:
3736       return "TI_INITINFO";
3737     case SHT_TI_PHATTRS:
3738       return "TI_PHATTRS";
3739     default:
3740       break;
3741     }
3742   return NULL;
3743 }
3744
3745 static const char *
3746 get_msp430x_section_type_name (unsigned int sh_type)
3747 {
3748   switch (sh_type)
3749     {
3750     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3751     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3752     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3753     default: return NULL;
3754     }
3755 }
3756
3757 static const char *
3758 get_v850_section_type_name (unsigned int sh_type)
3759 {
3760   switch (sh_type)
3761     {
3762     case SHT_V850_SCOMMON: return "V850 Small Common";
3763     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3764     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3765     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3766     case SHT_RENESAS_INFO: return "RENESAS INFO";
3767     default: return NULL;
3768     }
3769 }
3770
3771 static const char *
3772 get_section_type_name (unsigned int sh_type)
3773 {
3774   static char buff[32];
3775
3776   switch (sh_type)
3777     {
3778     case SHT_NULL:              return "NULL";
3779     case SHT_PROGBITS:          return "PROGBITS";
3780     case SHT_SYMTAB:            return "SYMTAB";
3781     case SHT_STRTAB:            return "STRTAB";
3782     case SHT_RELA:              return "RELA";
3783     case SHT_HASH:              return "HASH";
3784     case SHT_DYNAMIC:           return "DYNAMIC";
3785     case SHT_NOTE:              return "NOTE";
3786     case SHT_NOBITS:            return "NOBITS";
3787     case SHT_REL:               return "REL";
3788     case SHT_SHLIB:             return "SHLIB";
3789     case SHT_DYNSYM:            return "DYNSYM";
3790     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3791     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3792     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3793     case SHT_GNU_HASH:          return "GNU_HASH";
3794     case SHT_GROUP:             return "GROUP";
3795     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3796     case SHT_GNU_verdef:        return "VERDEF";
3797     case SHT_GNU_verneed:       return "VERNEED";
3798     case SHT_GNU_versym:        return "VERSYM";
3799     case 0x6ffffff0:            return "VERSYM";
3800     case 0x6ffffffc:            return "VERDEF";
3801     case 0x7ffffffd:            return "AUXILIARY";
3802     case 0x7fffffff:            return "FILTER";
3803     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3804
3805     default:
3806       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3807         {
3808           const char * result;
3809
3810           switch (elf_header.e_machine)
3811             {
3812             case EM_MIPS:
3813             case EM_MIPS_RS3_LE:
3814               result = get_mips_section_type_name (sh_type);
3815               break;
3816             case EM_PARISC:
3817               result = get_parisc_section_type_name (sh_type);
3818               break;
3819             case EM_IA_64:
3820               result = get_ia64_section_type_name (sh_type);
3821               break;
3822             case EM_X86_64:
3823             case EM_L1OM:
3824             case EM_K1OM:
3825               result = get_x86_64_section_type_name (sh_type);
3826               break;
3827             case EM_AARCH64:
3828               result = get_aarch64_section_type_name (sh_type);
3829               break;
3830             case EM_ARM:
3831               result = get_arm_section_type_name (sh_type);
3832               break;
3833             case EM_TI_C6000:
3834               result = get_tic6x_section_type_name (sh_type);
3835               break;
3836             case EM_MSP430:
3837               result = get_msp430x_section_type_name (sh_type);
3838               break;
3839             case EM_V800:
3840             case EM_V850:
3841             case EM_CYGNUS_V850:
3842               result = get_v850_section_type_name (sh_type);
3843               break;
3844             default:
3845               result = NULL;
3846               break;
3847             }
3848
3849           if (result != NULL)
3850             return result;
3851
3852           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3853         }
3854       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3855         {
3856           const char * result;
3857
3858           switch (elf_header.e_machine)
3859             {
3860             case EM_IA_64:
3861               result = get_ia64_section_type_name (sh_type);
3862               break;
3863             default:
3864               result = NULL;
3865               break;
3866             }
3867
3868           if (result != NULL)
3869             return result;
3870
3871           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3872         }
3873       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3874         {
3875           switch (elf_header.e_machine)
3876             {
3877             case EM_V800:
3878             case EM_V850:
3879             case EM_CYGNUS_V850:
3880               return get_v850_section_type_name (sh_type);
3881             default:
3882               break;
3883             }
3884
3885           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3886         }
3887       else
3888         /* This message is probably going to be displayed in a 15
3889            character wide field, so put the hex value first.  */
3890         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3891
3892       return buff;
3893     }
3894 }
3895
3896 #define OPTION_DEBUG_DUMP       512
3897 #define OPTION_DYN_SYMS         513
3898 #define OPTION_DWARF_DEPTH      514
3899 #define OPTION_DWARF_START      515
3900 #define OPTION_DWARF_CHECK      516
3901
3902 static struct option options[] =
3903 {
3904   {"all",              no_argument, 0, 'a'},
3905   {"file-header",      no_argument, 0, 'h'},
3906   {"program-headers",  no_argument, 0, 'l'},
3907   {"headers",          no_argument, 0, 'e'},
3908   {"histogram",        no_argument, 0, 'I'},
3909   {"segments",         no_argument, 0, 'l'},
3910   {"sections",         no_argument, 0, 'S'},
3911   {"section-headers",  no_argument, 0, 'S'},
3912   {"section-groups",   no_argument, 0, 'g'},
3913   {"section-details",  no_argument, 0, 't'},
3914   {"full-section-name",no_argument, 0, 'N'},
3915   {"symbols",          no_argument, 0, 's'},
3916   {"syms",             no_argument, 0, 's'},
3917   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3918   {"relocs",           no_argument, 0, 'r'},
3919   {"notes",            no_argument, 0, 'n'},
3920   {"dynamic",          no_argument, 0, 'd'},
3921   {"arch-specific",    no_argument, 0, 'A'},
3922   {"version-info",     no_argument, 0, 'V'},
3923   {"use-dynamic",      no_argument, 0, 'D'},
3924   {"unwind",           no_argument, 0, 'u'},
3925   {"archive-index",    no_argument, 0, 'c'},
3926   {"hex-dump",         required_argument, 0, 'x'},
3927   {"relocated-dump",   required_argument, 0, 'R'},
3928   {"string-dump",      required_argument, 0, 'p'},
3929 #ifdef SUPPORT_DISASSEMBLY
3930   {"instruction-dump", required_argument, 0, 'i'},
3931 #endif
3932   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3933
3934   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3935   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3936   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3937
3938   {"version",          no_argument, 0, 'v'},
3939   {"wide",             no_argument, 0, 'W'},
3940   {"help",             no_argument, 0, 'H'},
3941   {0,                  no_argument, 0, 0}
3942 };
3943
3944 static void
3945 usage (FILE * stream)
3946 {
3947   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3948   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3949   fprintf (stream, _(" Options are:\n\
3950   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3951   -h --file-header       Display the ELF file header\n\
3952   -l --program-headers   Display the program headers\n\
3953      --segments          An alias for --program-headers\n\
3954   -S --section-headers   Display the sections' header\n\
3955      --sections          An alias for --section-headers\n\
3956   -g --section-groups    Display the section groups\n\
3957   -t --section-details   Display the section details\n\
3958   -e --headers           Equivalent to: -h -l -S\n\
3959   -s --syms              Display the symbol table\n\
3960      --symbols           An alias for --syms\n\
3961   --dyn-syms             Display the dynamic symbol table\n\
3962   -n --notes             Display the core notes (if present)\n\
3963   -r --relocs            Display the relocations (if present)\n\
3964   -u --unwind            Display the unwind info (if present)\n\
3965   -d --dynamic           Display the dynamic section (if present)\n\
3966   -V --version-info      Display the version sections (if present)\n\
3967   -A --arch-specific     Display architecture specific information (if any)\n\
3968   -c --archive-index     Display the symbol/file index in an archive\n\
3969   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3970   -x --hex-dump=<number|name>\n\
3971                          Dump the contents of section <number|name> as bytes\n\
3972   -p --string-dump=<number|name>\n\
3973                          Dump the contents of section <number|name> as strings\n\
3974   -R --relocated-dump=<number|name>\n\
3975                          Dump the contents of section <number|name> as relocated bytes\n\
3976   -w[lLiaprmfFsoRt] or\n\
3977   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3978                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3979                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3980                =addr,=cu_index]\n\
3981                          Display the contents of DWARF2 debug sections\n"));
3982   fprintf (stream, _("\
3983   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3984   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3985                          or deeper\n"));
3986 #ifdef SUPPORT_DISASSEMBLY
3987   fprintf (stream, _("\
3988   -i --instruction-dump=<number|name>\n\
3989                          Disassemble the contents of section <number|name>\n"));
3990 #endif
3991   fprintf (stream, _("\
3992   -I --histogram         Display histogram of bucket list lengths\n\
3993   -W --wide              Allow output width to exceed 80 characters\n\
3994   @<file>                Read options from <file>\n\
3995   -H --help              Display this information\n\
3996   -v --version           Display the version number of readelf\n"));
3997
3998   if (REPORT_BUGS_TO[0] && stream == stdout)
3999     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4000
4001   exit (stream == stdout ? 0 : 1);
4002 }
4003
4004 /* Record the fact that the user wants the contents of section number
4005    SECTION to be displayed using the method(s) encoded as flags bits
4006    in TYPE.  Note, TYPE can be zero if we are creating the array for
4007    the first time.  */
4008
4009 static void
4010 request_dump_bynumber (unsigned int section, dump_type type)
4011 {
4012   if (section >= num_dump_sects)
4013     {
4014       dump_type * new_dump_sects;
4015
4016       new_dump_sects = (dump_type *) calloc (section + 1,
4017                                              sizeof (* dump_sects));
4018
4019       if (new_dump_sects == NULL)
4020         error (_("Out of memory allocating dump request table.\n"));
4021       else
4022         {
4023           /* Copy current flag settings.  */
4024           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4025
4026           free (dump_sects);
4027
4028           dump_sects = new_dump_sects;
4029           num_dump_sects = section + 1;
4030         }
4031     }
4032
4033   if (dump_sects)
4034     dump_sects[section] |= type;
4035
4036   return;
4037 }
4038
4039 /* Request a dump by section name.  */
4040
4041 static void
4042 request_dump_byname (const char * section, dump_type type)
4043 {
4044   struct dump_list_entry * new_request;
4045
4046   new_request = (struct dump_list_entry *)
4047       malloc (sizeof (struct dump_list_entry));
4048   if (!new_request)
4049     error (_("Out of memory allocating dump request table.\n"));
4050
4051   new_request->name = strdup (section);
4052   if (!new_request->name)
4053     error (_("Out of memory allocating dump request table.\n"));
4054
4055   new_request->type = type;
4056
4057   new_request->next = dump_sects_byname;
4058   dump_sects_byname = new_request;
4059 }
4060
4061 static inline void
4062 request_dump (dump_type type)
4063 {
4064   int section;
4065   char * cp;
4066
4067   do_dump++;
4068   section = strtoul (optarg, & cp, 0);
4069
4070   if (! *cp && section >= 0)
4071     request_dump_bynumber (section, type);
4072   else
4073     request_dump_byname (optarg, type);
4074 }
4075
4076
4077 static void
4078 parse_args (int argc, char ** argv)
4079 {
4080   int c;
4081
4082   if (argc < 2)
4083     usage (stderr);
4084
4085   while ((c = getopt_long
4086           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4087     {
4088       switch (c)
4089         {
4090         case 0:
4091           /* Long options.  */
4092           break;
4093         case 'H':
4094           usage (stdout);
4095           break;
4096
4097         case 'a':
4098           do_syms++;
4099           do_reloc++;
4100           do_unwind++;
4101           do_dynamic++;
4102           do_header++;
4103           do_sections++;
4104           do_section_groups++;
4105           do_segments++;
4106           do_version++;
4107           do_histogram++;
4108           do_arch++;
4109           do_notes++;
4110           break;
4111         case 'g':
4112           do_section_groups++;
4113           break;
4114         case 't':
4115         case 'N':
4116           do_sections++;
4117           do_section_details++;
4118           break;
4119         case 'e':
4120           do_header++;
4121           do_sections++;
4122           do_segments++;
4123           break;
4124         case 'A':
4125           do_arch++;
4126           break;
4127         case 'D':
4128           do_using_dynamic++;
4129           break;
4130         case 'r':
4131           do_reloc++;
4132           break;
4133         case 'u':
4134           do_unwind++;
4135           break;
4136         case 'h':
4137           do_header++;
4138           break;
4139         case 'l':
4140           do_segments++;
4141           break;
4142         case 's':
4143           do_syms++;
4144           break;
4145         case 'S':
4146           do_sections++;
4147           break;
4148         case 'd':
4149           do_dynamic++;
4150           break;
4151         case 'I':
4152           do_histogram++;
4153           break;
4154         case 'n':
4155           do_notes++;
4156           break;
4157         case 'c':
4158           do_archive_index++;
4159           break;
4160         case 'x':
4161           request_dump (HEX_DUMP);
4162           break;
4163         case 'p':
4164           request_dump (STRING_DUMP);
4165           break;
4166         case 'R':
4167           request_dump (RELOC_DUMP);
4168           break;
4169         case 'w':
4170           do_dump++;
4171           if (optarg == 0)
4172             {
4173               do_debugging = 1;
4174               dwarf_select_sections_all ();
4175             }
4176           else
4177             {
4178               do_debugging = 0;
4179               dwarf_select_sections_by_letters (optarg);
4180             }
4181           break;
4182         case OPTION_DEBUG_DUMP:
4183           do_dump++;
4184           if (optarg == 0)
4185             do_debugging = 1;
4186           else
4187             {
4188               do_debugging = 0;
4189               dwarf_select_sections_by_names (optarg);
4190             }
4191           break;
4192         case OPTION_DWARF_DEPTH:
4193           {
4194             char *cp;
4195
4196             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4197           }
4198           break;
4199         case OPTION_DWARF_START:
4200           {
4201             char *cp;
4202
4203             dwarf_start_die = strtoul (optarg, & cp, 0);
4204           }
4205           break;
4206         case OPTION_DWARF_CHECK:
4207           dwarf_check = 1;
4208           break;
4209         case OPTION_DYN_SYMS:
4210           do_dyn_syms++;
4211           break;
4212 #ifdef SUPPORT_DISASSEMBLY
4213         case 'i':
4214           request_dump (DISASS_DUMP);
4215           break;
4216 #endif
4217         case 'v':
4218           print_version (program_name);
4219           break;
4220         case 'V':
4221           do_version++;
4222           break;
4223         case 'W':
4224           do_wide++;
4225           break;
4226         default:
4227           /* xgettext:c-format */
4228           error (_("Invalid option '-%c'\n"), c);
4229           /* Drop through.  */
4230         case '?':
4231           usage (stderr);
4232         }
4233     }
4234
4235   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4236       && !do_segments && !do_header && !do_dump && !do_version
4237       && !do_histogram && !do_debugging && !do_arch && !do_notes
4238       && !do_section_groups && !do_archive_index
4239       && !do_dyn_syms)
4240     usage (stderr);
4241 }
4242
4243 static const char *
4244 get_elf_class (unsigned int elf_class)
4245 {
4246   static char buff[32];
4247
4248   switch (elf_class)
4249     {
4250     case ELFCLASSNONE: return _("none");
4251     case ELFCLASS32:   return "ELF32";
4252     case ELFCLASS64:   return "ELF64";
4253     default:
4254       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4255       return buff;
4256     }
4257 }
4258
4259 static const char *
4260 get_data_encoding (unsigned int encoding)
4261 {
4262   static char buff[32];
4263
4264   switch (encoding)
4265     {
4266     case ELFDATANONE: return _("none");
4267     case ELFDATA2LSB: return _("2's complement, little endian");
4268     case ELFDATA2MSB: return _("2's complement, big endian");
4269     default:
4270       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4271       return buff;
4272     }
4273 }
4274
4275 /* Decode the data held in 'elf_header'.  */
4276
4277 static int
4278 process_file_header (void)
4279 {
4280   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4281       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4282       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4283       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4284     {
4285       error
4286         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4287       return 0;
4288     }
4289
4290   init_dwarf_regnames (elf_header.e_machine);
4291
4292   if (do_header)
4293     {
4294       int i;
4295
4296       printf (_("ELF Header:\n"));
4297       printf (_("  Magic:   "));
4298       for (i = 0; i < EI_NIDENT; i++)
4299         printf ("%2.2x ", elf_header.e_ident[i]);
4300       printf ("\n");
4301       printf (_("  Class:                             %s\n"),
4302               get_elf_class (elf_header.e_ident[EI_CLASS]));
4303       printf (_("  Data:                              %s\n"),
4304               get_data_encoding (elf_header.e_ident[EI_DATA]));
4305       printf (_("  Version:                           %d %s\n"),
4306               elf_header.e_ident[EI_VERSION],
4307               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4308                ? "(current)"
4309                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4310                   ? _("<unknown: %lx>")
4311                   : "")));
4312       printf (_("  OS/ABI:                            %s\n"),
4313               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4314       printf (_("  ABI Version:                       %d\n"),
4315               elf_header.e_ident[EI_ABIVERSION]);
4316       printf (_("  Type:                              %s\n"),
4317               get_file_type (elf_header.e_type));
4318       printf (_("  Machine:                           %s\n"),
4319               get_machine_name (elf_header.e_machine));
4320       printf (_("  Version:                           0x%lx\n"),
4321               (unsigned long) elf_header.e_version);
4322
4323       printf (_("  Entry point address:               "));
4324       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4325       printf (_("\n  Start of program headers:          "));
4326       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4327       printf (_(" (bytes into file)\n  Start of section headers:          "));
4328       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4329       printf (_(" (bytes into file)\n"));
4330
4331       printf (_("  Flags:                             0x%lx%s\n"),
4332               (unsigned long) elf_header.e_flags,
4333               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4334       printf (_("  Size of this header:               %ld (bytes)\n"),
4335               (long) elf_header.e_ehsize);
4336       printf (_("  Size of program headers:           %ld (bytes)\n"),
4337               (long) elf_header.e_phentsize);
4338       printf (_("  Number of program headers:         %ld"),
4339               (long) elf_header.e_phnum);
4340       if (section_headers != NULL
4341           && elf_header.e_phnum == PN_XNUM
4342           && section_headers[0].sh_info != 0)
4343         printf (" (%ld)", (long) section_headers[0].sh_info);
4344       putc ('\n', stdout);
4345       printf (_("  Size of section headers:           %ld (bytes)\n"),
4346               (long) elf_header.e_shentsize);
4347       printf (_("  Number of section headers:         %ld"),
4348               (long) elf_header.e_shnum);
4349       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4350         printf (" (%ld)", (long) section_headers[0].sh_size);
4351       putc ('\n', stdout);
4352       printf (_("  Section header string table index: %ld"),
4353               (long) elf_header.e_shstrndx);
4354       if (section_headers != NULL
4355           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4356         printf (" (%u)", section_headers[0].sh_link);
4357       else if (elf_header.e_shstrndx != SHN_UNDEF
4358                && elf_header.e_shstrndx >= elf_header.e_shnum)
4359         printf (_(" <corrupt: out of range>"));
4360       putc ('\n', stdout);
4361     }
4362
4363   if (section_headers != NULL)
4364     {
4365       if (elf_header.e_phnum == PN_XNUM
4366           && section_headers[0].sh_info != 0)
4367         elf_header.e_phnum = section_headers[0].sh_info;
4368       if (elf_header.e_shnum == SHN_UNDEF)
4369         elf_header.e_shnum = section_headers[0].sh_size;
4370       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4371         elf_header.e_shstrndx = section_headers[0].sh_link;
4372       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4373         elf_header.e_shstrndx = SHN_UNDEF;
4374       free (section_headers);
4375       section_headers = NULL;
4376     }
4377
4378   return 1;
4379 }
4380
4381 static bfd_boolean
4382 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4383 {
4384   Elf32_External_Phdr * phdrs;
4385   Elf32_External_Phdr * external;
4386   Elf_Internal_Phdr *   internal;
4387   unsigned int i;
4388   unsigned int size = elf_header.e_phentsize;
4389   unsigned int num  = elf_header.e_phnum;
4390
4391   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4392   if (size == 0 || num == 0)
4393     return FALSE;
4394   if (size < sizeof * phdrs)
4395     {
4396       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4397       return FALSE;
4398     }
4399   if (size > sizeof * phdrs)
4400     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4401
4402   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4403                                             size, num, _("program headers"));
4404   if (phdrs == NULL)
4405     return FALSE;
4406
4407   for (i = 0, internal = pheaders, external = phdrs;
4408        i < elf_header.e_phnum;
4409        i++, internal++, external++)
4410     {
4411       internal->p_type   = BYTE_GET (external->p_type);
4412       internal->p_offset = BYTE_GET (external->p_offset);
4413       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4414       internal->p_paddr  = BYTE_GET (external->p_paddr);
4415       internal->p_filesz = BYTE_GET (external->p_filesz);
4416       internal->p_memsz  = BYTE_GET (external->p_memsz);
4417       internal->p_flags  = BYTE_GET (external->p_flags);
4418       internal->p_align  = BYTE_GET (external->p_align);
4419     }
4420
4421   free (phdrs);
4422   return TRUE;
4423 }
4424
4425 static bfd_boolean
4426 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4427 {
4428   Elf64_External_Phdr * phdrs;
4429   Elf64_External_Phdr * external;
4430   Elf_Internal_Phdr *   internal;
4431   unsigned int i;
4432   unsigned int size = elf_header.e_phentsize;
4433   unsigned int num  = elf_header.e_phnum;
4434
4435   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4436   if (size == 0 || num == 0)
4437     return FALSE;
4438   if (size < sizeof * phdrs)
4439     {
4440       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4441       return FALSE;
4442     }
4443   if (size > sizeof * phdrs)
4444     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4445
4446   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4447                                             size, num, _("program headers"));
4448   if (!phdrs)
4449     return FALSE;
4450
4451   for (i = 0, internal = pheaders, external = phdrs;
4452        i < elf_header.e_phnum;
4453        i++, internal++, external++)
4454     {
4455       internal->p_type   = BYTE_GET (external->p_type);
4456       internal->p_flags  = BYTE_GET (external->p_flags);
4457       internal->p_offset = BYTE_GET (external->p_offset);
4458       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4459       internal->p_paddr  = BYTE_GET (external->p_paddr);
4460       internal->p_filesz = BYTE_GET (external->p_filesz);
4461       internal->p_memsz  = BYTE_GET (external->p_memsz);
4462       internal->p_align  = BYTE_GET (external->p_align);
4463     }
4464
4465   free (phdrs);
4466   return TRUE;
4467 }
4468
4469 /* Returns 1 if the program headers were read into `program_headers'.  */
4470
4471 static int
4472 get_program_headers (FILE * file)
4473 {
4474   Elf_Internal_Phdr * phdrs;
4475
4476   /* Check cache of prior read.  */
4477   if (program_headers != NULL)
4478     return 1;
4479
4480   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4481                                          sizeof (Elf_Internal_Phdr));
4482
4483   if (phdrs == NULL)
4484     {
4485       error (_("Out of memory reading %u program headers\n"),
4486              elf_header.e_phnum);
4487       return 0;
4488     }
4489
4490   if (is_32bit_elf
4491       ? get_32bit_program_headers (file, phdrs)
4492       : get_64bit_program_headers (file, phdrs))
4493     {
4494       program_headers = phdrs;
4495       return 1;
4496     }
4497
4498   free (phdrs);
4499   return 0;
4500 }
4501
4502 /* Returns 1 if the program headers were loaded.  */
4503
4504 static int
4505 process_program_headers (FILE * file)
4506 {
4507   Elf_Internal_Phdr * segment;
4508   unsigned int i;
4509
4510   if (elf_header.e_phnum == 0)
4511     {
4512       /* PR binutils/12467.  */
4513       if (elf_header.e_phoff != 0)
4514         warn (_("possibly corrupt ELF header - it has a non-zero program"
4515                 " header offset, but no program headers\n"));
4516       else if (do_segments)
4517         printf (_("\nThere are no program headers in this file.\n"));
4518       return 0;
4519     }
4520
4521   if (do_segments && !do_header)
4522     {
4523       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4524       printf (_("Entry point "));
4525       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4526       printf (_("\nThere are %d program headers, starting at offset "),
4527               elf_header.e_phnum);
4528       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4529       printf ("\n");
4530     }
4531
4532   if (! get_program_headers (file))
4533       return 0;
4534
4535   if (do_segments)
4536     {
4537       if (elf_header.e_phnum > 1)
4538         printf (_("\nProgram Headers:\n"));
4539       else
4540         printf (_("\nProgram Headers:\n"));
4541
4542       if (is_32bit_elf)
4543         printf
4544           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4545       else if (do_wide)
4546         printf
4547           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4548       else
4549         {
4550           printf
4551             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4552           printf
4553             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4554         }
4555     }
4556
4557   dynamic_addr = 0;
4558   dynamic_size = 0;
4559
4560   for (i = 0, segment = program_headers;
4561        i < elf_header.e_phnum;
4562        i++, segment++)
4563     {
4564       if (do_segments)
4565         {
4566           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4567
4568           if (is_32bit_elf)
4569             {
4570               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4571               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4572               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4573               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4574               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4575               printf ("%c%c%c ",
4576                       (segment->p_flags & PF_R ? 'R' : ' '),
4577                       (segment->p_flags & PF_W ? 'W' : ' '),
4578                       (segment->p_flags & PF_X ? 'E' : ' '));
4579               printf ("%#lx", (unsigned long) segment->p_align);
4580             }
4581           else if (do_wide)
4582             {
4583               if ((unsigned long) segment->p_offset == segment->p_offset)
4584                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4585               else
4586                 {
4587                   print_vma (segment->p_offset, FULL_HEX);
4588                   putchar (' ');
4589                 }
4590
4591               print_vma (segment->p_vaddr, FULL_HEX);
4592               putchar (' ');
4593               print_vma (segment->p_paddr, FULL_HEX);
4594               putchar (' ');
4595
4596               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4597                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4598               else
4599                 {
4600                   print_vma (segment->p_filesz, FULL_HEX);
4601                   putchar (' ');
4602                 }
4603
4604               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4605                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4606               else
4607                 {
4608                   print_vma (segment->p_memsz, FULL_HEX);
4609                 }
4610
4611               printf (" %c%c%c ",
4612                       (segment->p_flags & PF_R ? 'R' : ' '),
4613                       (segment->p_flags & PF_W ? 'W' : ' '),
4614                       (segment->p_flags & PF_X ? 'E' : ' '));
4615
4616               if ((unsigned long) segment->p_align == segment->p_align)
4617                 printf ("%#lx", (unsigned long) segment->p_align);
4618               else
4619                 {
4620                   print_vma (segment->p_align, PREFIX_HEX);
4621                 }
4622             }
4623           else
4624             {
4625               print_vma (segment->p_offset, FULL_HEX);
4626               putchar (' ');
4627               print_vma (segment->p_vaddr, FULL_HEX);
4628               putchar (' ');
4629               print_vma (segment->p_paddr, FULL_HEX);
4630               printf ("\n                 ");
4631               print_vma (segment->p_filesz, FULL_HEX);
4632               putchar (' ');
4633               print_vma (segment->p_memsz, FULL_HEX);
4634               printf ("  %c%c%c    ",
4635                       (segment->p_flags & PF_R ? 'R' : ' '),
4636                       (segment->p_flags & PF_W ? 'W' : ' '),
4637                       (segment->p_flags & PF_X ? 'E' : ' '));
4638               print_vma (segment->p_align, HEX);
4639             }
4640         }
4641
4642       if (do_segments)
4643         putc ('\n', stdout);
4644
4645       switch (segment->p_type)
4646         {
4647         case PT_DYNAMIC:
4648           if (dynamic_addr)
4649             error (_("more than one dynamic segment\n"));
4650
4651           /* By default, assume that the .dynamic section is the first
4652              section in the DYNAMIC segment.  */
4653           dynamic_addr = segment->p_offset;
4654           dynamic_size = segment->p_filesz;
4655           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4656           if (dynamic_addr + dynamic_size >= current_file_size)
4657             {
4658               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4659               dynamic_addr = dynamic_size = 0;
4660             }
4661
4662           /* Try to locate the .dynamic section. If there is
4663              a section header table, we can easily locate it.  */
4664           if (section_headers != NULL)
4665             {
4666               Elf_Internal_Shdr * sec;
4667
4668               sec = find_section (".dynamic");
4669               if (sec == NULL || sec->sh_size == 0)
4670                 {
4671                   /* A corresponding .dynamic section is expected, but on
4672                      IA-64/OpenVMS it is OK for it to be missing.  */
4673                   if (!is_ia64_vms ())
4674                     error (_("no .dynamic section in the dynamic segment\n"));
4675                   break;
4676                 }
4677
4678               if (sec->sh_type == SHT_NOBITS)
4679                 {
4680                   dynamic_size = 0;
4681                   break;
4682                 }
4683
4684               dynamic_addr = sec->sh_offset;
4685               dynamic_size = sec->sh_size;
4686
4687               if (dynamic_addr < segment->p_offset
4688                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4689                 warn (_("the .dynamic section is not contained"
4690                         " within the dynamic segment\n"));
4691               else if (dynamic_addr > segment->p_offset)
4692                 warn (_("the .dynamic section is not the first section"
4693                         " in the dynamic segment.\n"));
4694             }
4695           break;
4696
4697         case PT_INTERP:
4698           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4699                      SEEK_SET))
4700             error (_("Unable to find program interpreter name\n"));
4701           else
4702             {
4703               char fmt [32];
4704               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4705
4706               if (ret >= (int) sizeof (fmt) || ret < 0)
4707                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4708
4709               program_interpreter[0] = 0;
4710               if (fscanf (file, fmt, program_interpreter) <= 0)
4711                 error (_("Unable to read program interpreter name\n"));
4712
4713               if (do_segments)
4714                 printf (_("      [Requesting program interpreter: %s]\n"),
4715                     program_interpreter);
4716             }
4717           break;
4718         }
4719     }
4720
4721   if (do_segments && section_headers != NULL && string_table != NULL)
4722     {
4723       printf (_("\n Section to Segment mapping:\n"));
4724       printf (_("  Segment Sections...\n"));
4725
4726       for (i = 0; i < elf_header.e_phnum; i++)
4727         {
4728           unsigned int j;
4729           Elf_Internal_Shdr * section;
4730
4731           segment = program_headers + i;
4732           section = section_headers + 1;
4733
4734           printf ("   %2.2d     ", i);
4735
4736           for (j = 1; j < elf_header.e_shnum; j++, section++)
4737             {
4738               if (!ELF_TBSS_SPECIAL (section, segment)
4739                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4740                 printf ("%s ", printable_section_name (section));
4741             }
4742
4743           putc ('\n',stdout);
4744         }
4745     }
4746
4747   return 1;
4748 }
4749
4750
4751 /* Find the file offset corresponding to VMA by using the program headers.  */
4752
4753 static long
4754 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4755 {
4756   Elf_Internal_Phdr * seg;
4757
4758   if (! get_program_headers (file))
4759     {
4760       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4761       return (long) vma;
4762     }
4763
4764   for (seg = program_headers;
4765        seg < program_headers + elf_header.e_phnum;
4766        ++seg)
4767     {
4768       if (seg->p_type != PT_LOAD)
4769         continue;
4770
4771       if (vma >= (seg->p_vaddr & -seg->p_align)
4772           && vma + size <= seg->p_vaddr + seg->p_filesz)
4773         return vma - seg->p_vaddr + seg->p_offset;
4774     }
4775
4776   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4777         (unsigned long) vma);
4778   return (long) vma;
4779 }
4780
4781
4782 /* Allocate memory and load the sections headers into the global pointer
4783    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4784    generate any error messages if the load fails.  */
4785
4786 static bfd_boolean
4787 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4788 {
4789   Elf32_External_Shdr * shdrs;
4790   Elf_Internal_Shdr *   internal;
4791   unsigned int i;
4792   unsigned int size = elf_header.e_shentsize;
4793   unsigned int num = probe ? 1 : elf_header.e_shnum;
4794
4795   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4796   if (size == 0 || num == 0)
4797     return FALSE;
4798   if (size < sizeof * shdrs)
4799     {
4800       if (! probe)
4801         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4802       return FALSE;
4803     }
4804   if (!probe && size > sizeof * shdrs)
4805     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4806
4807   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4808                                             size, num,
4809                                             probe ? NULL : _("section headers"));
4810   if (shdrs == NULL)
4811     return FALSE;
4812
4813   if (section_headers != NULL)
4814     free (section_headers);
4815   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4816                                                    sizeof (Elf_Internal_Shdr));
4817   if (section_headers == NULL)
4818     {
4819       if (!probe)
4820         error (_("Out of memory reading %u section headers\n"), num);
4821       return FALSE;
4822     }
4823
4824   for (i = 0, internal = section_headers;
4825        i < num;
4826        i++, internal++)
4827     {
4828       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4829       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4830       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4831       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4832       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4833       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4834       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4835       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4836       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4837       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4838     }
4839
4840   free (shdrs);
4841   return TRUE;
4842 }
4843
4844 static bfd_boolean
4845 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4846 {
4847   Elf64_External_Shdr * shdrs;
4848   Elf_Internal_Shdr *   internal;
4849   unsigned int i;
4850   unsigned int size = elf_header.e_shentsize;
4851   unsigned int num = probe ? 1 : elf_header.e_shnum;
4852
4853   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4854   if (size == 0 || num == 0)
4855     return FALSE;
4856   if (size < sizeof * shdrs)
4857     {
4858       if (! probe)
4859         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4860       return FALSE;
4861     }
4862   if (! probe && size > sizeof * shdrs)
4863     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4864
4865   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4866                                             size, num,
4867                                             probe ? NULL : _("section headers"));
4868   if (shdrs == NULL)
4869     return FALSE;
4870
4871   if (section_headers != NULL)
4872     free (section_headers);
4873   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4874                                                    sizeof (Elf_Internal_Shdr));
4875   if (section_headers == NULL)
4876     {
4877       if (! probe)
4878         error (_("Out of memory reading %u section headers\n"), num);
4879       return FALSE;
4880     }
4881
4882   for (i = 0, internal = section_headers;
4883        i < num;
4884        i++, internal++)
4885     {
4886       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4887       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4888       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4889       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4890       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4891       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4892       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4893       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4894       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4895       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4896     }
4897
4898   free (shdrs);
4899   return TRUE;
4900 }
4901
4902 static Elf_Internal_Sym *
4903 get_32bit_elf_symbols (FILE * file,
4904                        Elf_Internal_Shdr * section,
4905                        unsigned long * num_syms_return)
4906 {
4907   unsigned long number = 0;
4908   Elf32_External_Sym * esyms = NULL;
4909   Elf_External_Sym_Shndx * shndx = NULL;
4910   Elf_Internal_Sym * isyms = NULL;
4911   Elf_Internal_Sym * psym;
4912   unsigned int j;
4913
4914   if (section->sh_size == 0)
4915     {
4916       if (num_syms_return != NULL)
4917         * num_syms_return = 0;
4918       return NULL;
4919     }
4920
4921   /* Run some sanity checks first.  */
4922   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4923     {
4924       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4925              printable_section_name (section), (unsigned long) section->sh_entsize);
4926       goto exit_point;
4927     }
4928
4929   if (section->sh_size > current_file_size)
4930     {
4931       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4932              printable_section_name (section), (unsigned long) section->sh_size);
4933       goto exit_point;
4934     }
4935
4936   number = section->sh_size / section->sh_entsize;
4937
4938   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4939     {
4940       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4941              (unsigned long) section->sh_size,
4942              printable_section_name (section),
4943              (unsigned long) section->sh_entsize);
4944       goto exit_point;
4945     }
4946
4947   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4948                                            section->sh_size, _("symbols"));
4949   if (esyms == NULL)
4950     goto exit_point;
4951
4952   shndx = NULL;
4953   if (symtab_shndx_hdr != NULL
4954       && (symtab_shndx_hdr->sh_link
4955           == (unsigned long) (section - section_headers)))
4956     {
4957       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4958                                                    symtab_shndx_hdr->sh_offset,
4959                                                    1, symtab_shndx_hdr->sh_size,
4960                                                    _("symbol table section indicies"));
4961       if (shndx == NULL)
4962         goto exit_point;
4963       /* PR17531: file: heap-buffer-overflow */
4964       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4965         {
4966           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4967                  printable_section_name (symtab_shndx_hdr),
4968                  (unsigned long) symtab_shndx_hdr->sh_size,
4969                  (unsigned long) section->sh_size);
4970           goto exit_point;
4971         }
4972     }
4973
4974   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4975
4976   if (isyms == NULL)
4977     {
4978       error (_("Out of memory reading %lu symbols\n"),
4979              (unsigned long) number);
4980       goto exit_point;
4981     }
4982
4983   for (j = 0, psym = isyms; j < number; j++, psym++)
4984     {
4985       psym->st_name  = BYTE_GET (esyms[j].st_name);
4986       psym->st_value = BYTE_GET (esyms[j].st_value);
4987       psym->st_size  = BYTE_GET (esyms[j].st_size);
4988       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4989       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4990         psym->st_shndx
4991           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4992       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4993         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4994       psym->st_info  = BYTE_GET (esyms[j].st_info);
4995       psym->st_other = BYTE_GET (esyms[j].st_other);
4996     }
4997
4998  exit_point:
4999   if (shndx != NULL)
5000     free (shndx);
5001   if (esyms != NULL)
5002     free (esyms);
5003
5004   if (num_syms_return != NULL)
5005     * num_syms_return = isyms == NULL ? 0 : number;
5006
5007   return isyms;
5008 }
5009
5010 static Elf_Internal_Sym *
5011 get_64bit_elf_symbols (FILE * file,
5012                        Elf_Internal_Shdr * section,
5013                        unsigned long * num_syms_return)
5014 {
5015   unsigned long number = 0;
5016   Elf64_External_Sym * esyms = NULL;
5017   Elf_External_Sym_Shndx * shndx = NULL;
5018   Elf_Internal_Sym * isyms = NULL;
5019   Elf_Internal_Sym * psym;
5020   unsigned int j;
5021
5022   if (section->sh_size == 0)
5023     {
5024       if (num_syms_return != NULL)
5025         * num_syms_return = 0;
5026       return NULL;
5027     }
5028
5029   /* Run some sanity checks first.  */
5030   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5031     {
5032       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5033              printable_section_name (section),
5034              (unsigned long) section->sh_entsize);
5035       goto exit_point;
5036     }
5037
5038   if (section->sh_size > current_file_size)
5039     {
5040       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5041              printable_section_name (section),
5042              (unsigned long) section->sh_size);
5043       goto exit_point;
5044     }
5045
5046   number = section->sh_size / section->sh_entsize;
5047
5048   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5049     {
5050       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5051              (unsigned long) section->sh_size,
5052              printable_section_name (section),
5053              (unsigned long) section->sh_entsize);
5054       goto exit_point;
5055     }
5056
5057   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5058                                            section->sh_size, _("symbols"));
5059   if (!esyms)
5060     goto exit_point;
5061
5062   if (symtab_shndx_hdr != NULL
5063       && (symtab_shndx_hdr->sh_link
5064           == (unsigned long) (section - section_headers)))
5065     {
5066       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5067                                                    symtab_shndx_hdr->sh_offset,
5068                                                    1, symtab_shndx_hdr->sh_size,
5069                                                    _("symbol table section indicies"));
5070       if (shndx == NULL)
5071         goto exit_point;
5072       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5073         {
5074           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5075                  printable_section_name (symtab_shndx_hdr),
5076                  (unsigned long) symtab_shndx_hdr->sh_size,
5077                  (unsigned long) section->sh_size);
5078           goto exit_point;
5079         }
5080     }
5081
5082   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5083
5084   if (isyms == NULL)
5085     {
5086       error (_("Out of memory reading %lu symbols\n"),
5087              (unsigned long) number);
5088       goto exit_point;
5089     }
5090
5091   for (j = 0, psym = isyms; j < number; j++, psym++)
5092     {
5093       psym->st_name  = BYTE_GET (esyms[j].st_name);
5094       psym->st_info  = BYTE_GET (esyms[j].st_info);
5095       psym->st_other = BYTE_GET (esyms[j].st_other);
5096       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5097
5098       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5099         psym->st_shndx
5100           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5101       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5102         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5103
5104       psym->st_value = BYTE_GET (esyms[j].st_value);
5105       psym->st_size  = BYTE_GET (esyms[j].st_size);
5106     }
5107
5108  exit_point:
5109   if (shndx != NULL)
5110     free (shndx);
5111   if (esyms != NULL)
5112     free (esyms);
5113
5114   if (num_syms_return != NULL)
5115     * num_syms_return = isyms == NULL ? 0 : number;
5116
5117   return isyms;
5118 }
5119
5120 static const char *
5121 get_elf_section_flags (bfd_vma sh_flags)
5122 {
5123   static char buff[1024];
5124   char * p = buff;
5125   int field_size = is_32bit_elf ? 8 : 16;
5126   int sindex;
5127   int size = sizeof (buff) - (field_size + 4 + 1);
5128   bfd_vma os_flags = 0;
5129   bfd_vma proc_flags = 0;
5130   bfd_vma unknown_flags = 0;
5131   static const struct
5132     {
5133       const char * str;
5134       int len;
5135     }
5136   flags [] =
5137     {
5138       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5139       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5140       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5141       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5142       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5143       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5144       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5145       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5146       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5147       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5148       /* IA-64 specific.  */
5149       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5150       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5151       /* IA-64 OpenVMS specific.  */
5152       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5153       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5154       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5155       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5156       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5157       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5158       /* Generic.  */
5159       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5160       /* SPARC specific.  */
5161       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5162       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5163     };
5164
5165   if (do_section_details)
5166     {
5167       sprintf (buff, "[%*.*lx]: ",
5168                field_size, field_size, (unsigned long) sh_flags);
5169       p += field_size + 4;
5170     }
5171
5172   while (sh_flags)
5173     {
5174       bfd_vma flag;
5175
5176       flag = sh_flags & - sh_flags;
5177       sh_flags &= ~ flag;
5178
5179       if (do_section_details)
5180         {
5181           switch (flag)
5182             {
5183             case SHF_WRITE:             sindex = 0; break;
5184             case SHF_ALLOC:             sindex = 1; break;
5185             case SHF_EXECINSTR:         sindex = 2; break;
5186             case SHF_MERGE:             sindex = 3; break;
5187             case SHF_STRINGS:           sindex = 4; break;
5188             case SHF_INFO_LINK:         sindex = 5; break;
5189             case SHF_LINK_ORDER:        sindex = 6; break;
5190             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5191             case SHF_GROUP:             sindex = 8; break;
5192             case SHF_TLS:               sindex = 9; break;
5193             case SHF_EXCLUDE:           sindex = 18; break;
5194             case SHF_COMPRESSED:        sindex = 20; break;
5195
5196             default:
5197               sindex = -1;
5198               switch (elf_header.e_machine)
5199                 {
5200                 case EM_IA_64:
5201                   if (flag == SHF_IA_64_SHORT)
5202                     sindex = 10;
5203                   else if (flag == SHF_IA_64_NORECOV)
5204                     sindex = 11;
5205 #ifdef BFD64
5206                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5207                     switch (flag)
5208                       {
5209                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5210                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5211                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5212                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5213                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5214                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5215                       default:                        break;
5216                       }
5217 #endif
5218                   break;
5219
5220                 case EM_386:
5221                 case EM_486:
5222                 case EM_X86_64:
5223                 case EM_L1OM:
5224                 case EM_K1OM:
5225                 case EM_OLD_SPARCV9:
5226                 case EM_SPARC32PLUS:
5227                 case EM_SPARCV9:
5228                 case EM_SPARC:
5229                   if (flag == SHF_ORDERED)
5230                     sindex = 19;
5231                   break;
5232                 default:
5233                   break;
5234                 }
5235             }
5236
5237           if (sindex != -1)
5238             {
5239               if (p != buff + field_size + 4)
5240                 {
5241                   if (size < (10 + 2))
5242                     {
5243                       warn (_("Internal error: not enough buffer room for section flag info"));
5244                       return _("<unknown>");
5245                     }
5246                   size -= 2;
5247                   *p++ = ',';
5248                   *p++ = ' ';
5249                 }
5250
5251               size -= flags [sindex].len;
5252               p = stpcpy (p, flags [sindex].str);
5253             }
5254           else if (flag & SHF_MASKOS)
5255             os_flags |= flag;
5256           else if (flag & SHF_MASKPROC)
5257             proc_flags |= flag;
5258           else
5259             unknown_flags |= flag;
5260         }
5261       else
5262         {
5263           switch (flag)
5264             {
5265             case SHF_WRITE:             *p = 'W'; break;
5266             case SHF_ALLOC:             *p = 'A'; break;
5267             case SHF_EXECINSTR:         *p = 'X'; break;
5268             case SHF_MERGE:             *p = 'M'; break;
5269             case SHF_STRINGS:           *p = 'S'; break;
5270             case SHF_INFO_LINK:         *p = 'I'; break;
5271             case SHF_LINK_ORDER:        *p = 'L'; break;
5272             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5273             case SHF_GROUP:             *p = 'G'; break;
5274             case SHF_TLS:               *p = 'T'; break;
5275             case SHF_EXCLUDE:           *p = 'E'; break;
5276             case SHF_COMPRESSED:        *p = 'C'; break;
5277
5278             default:
5279               if ((elf_header.e_machine == EM_X86_64
5280                    || elf_header.e_machine == EM_L1OM
5281                    || elf_header.e_machine == EM_K1OM)
5282                   && flag == SHF_X86_64_LARGE)
5283                 *p = 'l';
5284               else if (flag & SHF_MASKOS)
5285                 {
5286                   *p = 'o';
5287                   sh_flags &= ~ SHF_MASKOS;
5288                 }
5289               else if (flag & SHF_MASKPROC)
5290                 {
5291                   *p = 'p';
5292                   sh_flags &= ~ SHF_MASKPROC;
5293                 }
5294               else
5295                 *p = 'x';
5296               break;
5297             }
5298           p++;
5299         }
5300     }
5301
5302   if (do_section_details)
5303     {
5304       if (os_flags)
5305         {
5306           size -= 5 + field_size;
5307           if (p != buff + field_size + 4)
5308             {
5309               if (size < (2 + 1))
5310                 {
5311                   warn (_("Internal error: not enough buffer room for section flag info"));
5312                   return _("<unknown>");
5313                 }
5314               size -= 2;
5315               *p++ = ',';
5316               *p++ = ' ';
5317             }
5318           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5319                    (unsigned long) os_flags);
5320           p += 5 + field_size;
5321         }
5322       if (proc_flags)
5323         {
5324           size -= 7 + field_size;
5325           if (p != buff + field_size + 4)
5326             {
5327               if (size < (2 + 1))
5328                 {
5329                   warn (_("Internal error: not enough buffer room for section flag info"));
5330                   return _("<unknown>");
5331                 }
5332               size -= 2;
5333               *p++ = ',';
5334               *p++ = ' ';
5335             }
5336           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5337                    (unsigned long) proc_flags);
5338           p += 7 + field_size;
5339         }
5340       if (unknown_flags)
5341         {
5342           size -= 10 + field_size;
5343           if (p != buff + field_size + 4)
5344             {
5345               if (size < (2 + 1))
5346                 {
5347                   warn (_("Internal error: not enough buffer room for section flag info"));
5348                   return _("<unknown>");
5349                 }
5350               size -= 2;
5351               *p++ = ',';
5352               *p++ = ' ';
5353             }
5354           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5355                    (unsigned long) unknown_flags);
5356           p += 10 + field_size;
5357         }
5358     }
5359
5360   *p = '\0';
5361   return buff;
5362 }
5363
5364 static unsigned int
5365 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5366 {
5367   if (is_32bit_elf)
5368     {
5369       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5370       chdr->ch_type = BYTE_GET (echdr->ch_type);
5371       chdr->ch_size = BYTE_GET (echdr->ch_size);
5372       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5373       return sizeof (*echdr);
5374     }
5375   else
5376     {
5377       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5378       chdr->ch_type = BYTE_GET (echdr->ch_type);
5379       chdr->ch_size = BYTE_GET (echdr->ch_size);
5380       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5381       return sizeof (*echdr);
5382     }
5383 }
5384
5385 static int
5386 process_section_headers (FILE * file)
5387 {
5388   Elf_Internal_Shdr * section;
5389   unsigned int i;
5390
5391   section_headers = NULL;
5392
5393   if (elf_header.e_shnum == 0)
5394     {
5395       /* PR binutils/12467.  */
5396       if (elf_header.e_shoff != 0)
5397         warn (_("possibly corrupt ELF file header - it has a non-zero"
5398                 " section header offset, but no section headers\n"));
5399       else if (do_sections)
5400         printf (_("\nThere are no sections in this file.\n"));
5401
5402       return 1;
5403     }
5404
5405   if (do_sections && !do_header)
5406     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5407             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5408
5409   if (is_32bit_elf)
5410     {
5411       if (! get_32bit_section_headers (file, FALSE))
5412         return 0;
5413     }
5414   else if (! get_64bit_section_headers (file, FALSE))
5415     return 0;
5416
5417   /* Read in the string table, so that we have names to display.  */
5418   if (elf_header.e_shstrndx != SHN_UNDEF
5419        && elf_header.e_shstrndx < elf_header.e_shnum)
5420     {
5421       section = section_headers + elf_header.e_shstrndx;
5422
5423       if (section->sh_size != 0)
5424         {
5425           string_table = (char *) get_data (NULL, file, section->sh_offset,
5426                                             1, section->sh_size,
5427                                             _("string table"));
5428
5429           string_table_length = string_table != NULL ? section->sh_size : 0;
5430         }
5431     }
5432
5433   /* Scan the sections for the dynamic symbol table
5434      and dynamic string table and debug sections.  */
5435   dynamic_symbols = NULL;
5436   dynamic_strings = NULL;
5437   dynamic_syminfo = NULL;
5438   symtab_shndx_hdr = NULL;
5439
5440   eh_addr_size = is_32bit_elf ? 4 : 8;
5441   switch (elf_header.e_machine)
5442     {
5443     case EM_MIPS:
5444     case EM_MIPS_RS3_LE:
5445       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5446          FDE addresses.  However, the ABI also has a semi-official ILP32
5447          variant for which the normal FDE address size rules apply.
5448
5449          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5450          section, where XX is the size of longs in bits.  Unfortunately,
5451          earlier compilers provided no way of distinguishing ILP32 objects
5452          from LP64 objects, so if there's any doubt, we should assume that
5453          the official LP64 form is being used.  */
5454       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5455           && find_section (".gcc_compiled_long32") == NULL)
5456         eh_addr_size = 8;
5457       break;
5458
5459     case EM_H8_300:
5460     case EM_H8_300H:
5461       switch (elf_header.e_flags & EF_H8_MACH)
5462         {
5463         case E_H8_MACH_H8300:
5464         case E_H8_MACH_H8300HN:
5465         case E_H8_MACH_H8300SN:
5466         case E_H8_MACH_H8300SXN:
5467           eh_addr_size = 2;
5468           break;
5469         case E_H8_MACH_H8300H:
5470         case E_H8_MACH_H8300S:
5471         case E_H8_MACH_H8300SX:
5472           eh_addr_size = 4;
5473           break;
5474         }
5475       break;
5476
5477     case EM_M32C_OLD:
5478     case EM_M32C:
5479       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5480         {
5481         case EF_M32C_CPU_M16C:
5482           eh_addr_size = 2;
5483           break;
5484         }
5485       break;
5486     }
5487
5488 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5489   do                                                                    \
5490     {                                                                   \
5491       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5492       if (section->sh_entsize != expected_entsize)                      \
5493         {                                                               \
5494           char buf[40];                                                 \
5495           sprintf_vma (buf, section->sh_entsize);                       \
5496           /* Note: coded this way so that there is a single string for  \
5497              translation.  */ \
5498           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5499           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5500                    (unsigned) expected_entsize);                        \
5501           section->sh_entsize = expected_entsize;                       \
5502         }                                                               \
5503     }                                                                   \
5504   while (0)
5505
5506 #define CHECK_ENTSIZE(section, i, type)                                 \
5507   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5508                         sizeof (Elf64_External_##type))
5509
5510   for (i = 0, section = section_headers;
5511        i < elf_header.e_shnum;
5512        i++, section++)
5513     {
5514       char * name = SECTION_NAME (section);
5515
5516       if (section->sh_type == SHT_DYNSYM)
5517         {
5518           if (dynamic_symbols != NULL)
5519             {
5520               error (_("File contains multiple dynamic symbol tables\n"));
5521               continue;
5522             }
5523
5524           CHECK_ENTSIZE (section, i, Sym);
5525           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5526         }
5527       else if (section->sh_type == SHT_STRTAB
5528                && streq (name, ".dynstr"))
5529         {
5530           if (dynamic_strings != NULL)
5531             {
5532               error (_("File contains multiple dynamic string tables\n"));
5533               continue;
5534             }
5535
5536           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5537                                                1, section->sh_size,
5538                                                _("dynamic strings"));
5539           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5540         }
5541       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5542         {
5543           if (symtab_shndx_hdr != NULL)
5544             {
5545               error (_("File contains multiple symtab shndx tables\n"));
5546               continue;
5547             }
5548           symtab_shndx_hdr = section;
5549         }
5550       else if (section->sh_type == SHT_SYMTAB)
5551         CHECK_ENTSIZE (section, i, Sym);
5552       else if (section->sh_type == SHT_GROUP)
5553         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5554       else if (section->sh_type == SHT_REL)
5555         CHECK_ENTSIZE (section, i, Rel);
5556       else if (section->sh_type == SHT_RELA)
5557         CHECK_ENTSIZE (section, i, Rela);
5558       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5559                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5560                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5561                 || do_debug_str || do_debug_loc || do_debug_ranges
5562                 || do_debug_addr || do_debug_cu_index)
5563                && (const_strneq (name, ".debug_")
5564                    || const_strneq (name, ".zdebug_")))
5565         {
5566           if (name[1] == 'z')
5567             name += sizeof (".zdebug_") - 1;
5568           else
5569             name += sizeof (".debug_") - 1;
5570
5571           if (do_debugging
5572               || (do_debug_info     && const_strneq (name, "info"))
5573               || (do_debug_info     && const_strneq (name, "types"))
5574               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5575               || (do_debug_lines    && strcmp (name, "line") == 0)
5576               || (do_debug_lines    && const_strneq (name, "line."))
5577               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5578               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5579               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5580               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5581               || (do_debug_aranges  && const_strneq (name, "aranges"))
5582               || (do_debug_ranges   && const_strneq (name, "ranges"))
5583               || (do_debug_frames   && const_strneq (name, "frame"))
5584               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5585               || (do_debug_macinfo  && const_strneq (name, "macro"))
5586               || (do_debug_str      && const_strneq (name, "str"))
5587               || (do_debug_loc      && const_strneq (name, "loc"))
5588               || (do_debug_addr     && const_strneq (name, "addr"))
5589               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5590               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5591               )
5592             request_dump_bynumber (i, DEBUG_DUMP);
5593         }
5594       /* Linkonce section to be combined with .debug_info at link time.  */
5595       else if ((do_debugging || do_debug_info)
5596                && const_strneq (name, ".gnu.linkonce.wi."))
5597         request_dump_bynumber (i, DEBUG_DUMP);
5598       else if (do_debug_frames && streq (name, ".eh_frame"))
5599         request_dump_bynumber (i, DEBUG_DUMP);
5600       else if (do_gdb_index && streq (name, ".gdb_index"))
5601         request_dump_bynumber (i, DEBUG_DUMP);
5602       /* Trace sections for Itanium VMS.  */
5603       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5604                 || do_trace_aranges)
5605                && const_strneq (name, ".trace_"))
5606         {
5607           name += sizeof (".trace_") - 1;
5608
5609           if (do_debugging
5610               || (do_trace_info     && streq (name, "info"))
5611               || (do_trace_abbrevs  && streq (name, "abbrev"))
5612               || (do_trace_aranges  && streq (name, "aranges"))
5613               )
5614             request_dump_bynumber (i, DEBUG_DUMP);
5615         }
5616     }
5617
5618   if (! do_sections)
5619     return 1;
5620
5621   if (elf_header.e_shnum > 1)
5622     printf (_("\nSection Headers:\n"));
5623   else
5624     printf (_("\nSection Header:\n"));
5625
5626   if (is_32bit_elf)
5627     {
5628       if (do_section_details)
5629         {
5630           printf (_("  [Nr] Name\n"));
5631           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5632         }
5633       else
5634         printf
5635           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5636     }
5637   else if (do_wide)
5638     {
5639       if (do_section_details)
5640         {
5641           printf (_("  [Nr] Name\n"));
5642           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5643         }
5644       else
5645         printf
5646           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5647     }
5648   else
5649     {
5650       if (do_section_details)
5651         {
5652           printf (_("  [Nr] Name\n"));
5653           printf (_("       Type              Address          Offset            Link\n"));
5654           printf (_("       Size              EntSize          Info              Align\n"));
5655         }
5656       else
5657         {
5658           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5659           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5660         }
5661     }
5662
5663   if (do_section_details)
5664     printf (_("       Flags\n"));
5665
5666   for (i = 0, section = section_headers;
5667        i < elf_header.e_shnum;
5668        i++, section++)
5669     {
5670       printf ("  [%2u] ", i);
5671       if (do_section_details)
5672         printf ("%s\n      ", printable_section_name (section));
5673       else
5674         print_symbol (-17, SECTION_NAME (section));
5675
5676       printf (do_wide ? " %-15s " : " %-15.15s ",
5677               get_section_type_name (section->sh_type));
5678
5679       if (is_32bit_elf)
5680         {
5681           const char * link_too_big = NULL;
5682
5683           print_vma (section->sh_addr, LONG_HEX);
5684
5685           printf ( " %6.6lx %6.6lx %2.2lx",
5686                    (unsigned long) section->sh_offset,
5687                    (unsigned long) section->sh_size,
5688                    (unsigned long) section->sh_entsize);
5689
5690           if (do_section_details)
5691             fputs ("  ", stdout);
5692           else
5693             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5694
5695           if (section->sh_link >= elf_header.e_shnum)
5696             {
5697               link_too_big = "";
5698               /* The sh_link value is out of range.  Normally this indicates
5699                  an error but it can have special values in Solaris binaries.  */
5700               switch (elf_header.e_machine)
5701                 {
5702                 case EM_386:
5703                 case EM_486:
5704                 case EM_X86_64:
5705                 case EM_L1OM:
5706                 case EM_K1OM:
5707                 case EM_OLD_SPARCV9:
5708                 case EM_SPARC32PLUS:
5709                 case EM_SPARCV9:
5710                 case EM_SPARC:
5711                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5712                     link_too_big = "BEFORE";
5713                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5714                     link_too_big = "AFTER";
5715                   break;
5716                 default:
5717                   break;
5718                 }
5719             }
5720
5721           if (do_section_details)
5722             {
5723               if (link_too_big != NULL && * link_too_big)
5724                 printf ("<%s> ", link_too_big);
5725               else
5726                 printf ("%2u ", section->sh_link);
5727               printf ("%3u %2lu\n", section->sh_info,
5728                       (unsigned long) section->sh_addralign);
5729             }
5730           else
5731             printf ("%2u %3u %2lu\n",
5732                     section->sh_link,
5733                     section->sh_info,
5734                     (unsigned long) section->sh_addralign);
5735
5736           if (link_too_big && ! * link_too_big)
5737             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5738                   i, section->sh_link);
5739         }
5740       else if (do_wide)
5741         {
5742           print_vma (section->sh_addr, LONG_HEX);
5743
5744           if ((long) section->sh_offset == section->sh_offset)
5745             printf (" %6.6lx", (unsigned long) section->sh_offset);
5746           else
5747             {
5748               putchar (' ');
5749               print_vma (section->sh_offset, LONG_HEX);
5750             }
5751
5752           if ((unsigned long) section->sh_size == section->sh_size)
5753             printf (" %6.6lx", (unsigned long) section->sh_size);
5754           else
5755             {
5756               putchar (' ');
5757               print_vma (section->sh_size, LONG_HEX);
5758             }
5759
5760           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5761             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5762           else
5763             {
5764               putchar (' ');
5765               print_vma (section->sh_entsize, LONG_HEX);
5766             }
5767
5768           if (do_section_details)
5769             fputs ("  ", stdout);
5770           else
5771             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5772
5773           printf ("%2u %3u ", section->sh_link, section->sh_info);
5774
5775           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5776             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5777           else
5778             {
5779               print_vma (section->sh_addralign, DEC);
5780               putchar ('\n');
5781             }
5782         }
5783       else if (do_section_details)
5784         {
5785           printf ("       %-15.15s  ",
5786                   get_section_type_name (section->sh_type));
5787           print_vma (section->sh_addr, LONG_HEX);
5788           if ((long) section->sh_offset == section->sh_offset)
5789             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5790           else
5791             {
5792               printf ("  ");
5793               print_vma (section->sh_offset, LONG_HEX);
5794             }
5795           printf ("  %u\n       ", section->sh_link);
5796           print_vma (section->sh_size, LONG_HEX);
5797           putchar (' ');
5798           print_vma (section->sh_entsize, LONG_HEX);
5799
5800           printf ("  %-16u  %lu\n",
5801                   section->sh_info,
5802                   (unsigned long) section->sh_addralign);
5803         }
5804       else
5805         {
5806           putchar (' ');
5807           print_vma (section->sh_addr, LONG_HEX);
5808           if ((long) section->sh_offset == section->sh_offset)
5809             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5810           else
5811             {
5812               printf ("  ");
5813               print_vma (section->sh_offset, LONG_HEX);
5814             }
5815           printf ("\n       ");
5816           print_vma (section->sh_size, LONG_HEX);
5817           printf ("  ");
5818           print_vma (section->sh_entsize, LONG_HEX);
5819
5820           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5821
5822           printf ("     %2u   %3u     %lu\n",
5823                   section->sh_link,
5824                   section->sh_info,
5825                   (unsigned long) section->sh_addralign);
5826         }
5827
5828       if (do_section_details)
5829         {
5830           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5831           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5832             {
5833               /* Minimum section size is 12 bytes for 32-bit compression
5834                  header + 12 bytes for compressed data header.  */
5835               unsigned char buf[24];
5836               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5837               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5838                             sizeof (buf), _("compression header")))
5839                 {
5840                   Elf_Internal_Chdr chdr;
5841                   get_compression_header (&chdr, buf);
5842                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5843                     printf ("       ZLIB, ");
5844                   else
5845                     printf (_("       [<unknown>: 0x%x], "),
5846                             chdr.ch_type);
5847                   print_vma (chdr.ch_size, LONG_HEX);
5848                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5849                 }
5850             }
5851         }
5852     }
5853
5854   if (!do_section_details)
5855     {
5856       if (elf_header.e_machine == EM_X86_64
5857           || elf_header.e_machine == EM_L1OM
5858           || elf_header.e_machine == EM_K1OM)
5859         printf (_("Key to Flags:\n\
5860   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5861   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5862   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5863       else
5864         printf (_("Key to Flags:\n\
5865   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5866   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5867   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5868     }
5869
5870   return 1;
5871 }
5872
5873 static const char *
5874 get_group_flags (unsigned int flags)
5875 {
5876   static char buff[32];
5877   switch (flags)
5878     {
5879     case 0:
5880       return "";
5881
5882     case GRP_COMDAT:
5883       return "COMDAT ";
5884
5885    default:
5886       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5887       break;
5888     }
5889   return buff;
5890 }
5891
5892 static int
5893 process_section_groups (FILE * file)
5894 {
5895   Elf_Internal_Shdr * section;
5896   unsigned int i;
5897   struct group * group;
5898   Elf_Internal_Shdr * symtab_sec;
5899   Elf_Internal_Shdr * strtab_sec;
5900   Elf_Internal_Sym * symtab;
5901   unsigned long num_syms;
5902   char * strtab;
5903   size_t strtab_size;
5904
5905   /* Don't process section groups unless needed.  */
5906   if (!do_unwind && !do_section_groups)
5907     return 1;
5908
5909   if (elf_header.e_shnum == 0)
5910     {
5911       if (do_section_groups)
5912         printf (_("\nThere are no sections to group in this file.\n"));
5913
5914       return 1;
5915     }
5916
5917   if (section_headers == NULL)
5918     {
5919       error (_("Section headers are not available!\n"));
5920       /* PR 13622: This can happen with a corrupt ELF header.  */
5921       return 0;
5922     }
5923
5924   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5925                                                      sizeof (struct group *));
5926
5927   if (section_headers_groups == NULL)
5928     {
5929       error (_("Out of memory reading %u section group headers\n"),
5930              elf_header.e_shnum);
5931       return 0;
5932     }
5933
5934   /* Scan the sections for the group section.  */
5935   group_count = 0;
5936   for (i = 0, section = section_headers;
5937        i < elf_header.e_shnum;
5938        i++, section++)
5939     if (section->sh_type == SHT_GROUP)
5940       group_count++;
5941
5942   if (group_count == 0)
5943     {
5944       if (do_section_groups)
5945         printf (_("\nThere are no section groups in this file.\n"));
5946
5947       return 1;
5948     }
5949
5950   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5951
5952   if (section_groups == NULL)
5953     {
5954       error (_("Out of memory reading %lu groups\n"),
5955              (unsigned long) group_count);
5956       return 0;
5957     }
5958
5959   symtab_sec = NULL;
5960   strtab_sec = NULL;
5961   symtab = NULL;
5962   num_syms = 0;
5963   strtab = NULL;
5964   strtab_size = 0;
5965   for (i = 0, section = section_headers, group = section_groups;
5966        i < elf_header.e_shnum;
5967        i++, section++)
5968     {
5969       if (section->sh_type == SHT_GROUP)
5970         {
5971           const char * name = printable_section_name (section);
5972           const char * group_name;
5973           unsigned char * start;
5974           unsigned char * indices;
5975           unsigned int entry, j, size;
5976           Elf_Internal_Shdr * sec;
5977           Elf_Internal_Sym * sym;
5978
5979           /* Get the symbol table.  */
5980           if (section->sh_link >= elf_header.e_shnum
5981               || ((sec = section_headers + section->sh_link)->sh_type
5982                   != SHT_SYMTAB))
5983             {
5984               error (_("Bad sh_link in group section `%s'\n"), name);
5985               continue;
5986             }
5987
5988           if (symtab_sec != sec)
5989             {
5990               symtab_sec = sec;
5991               if (symtab)
5992                 free (symtab);
5993               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5994             }
5995
5996           if (symtab == NULL)
5997             {
5998               error (_("Corrupt header in group section `%s'\n"), name);
5999               continue;
6000             }
6001
6002           if (section->sh_info >= num_syms)
6003             {
6004               error (_("Bad sh_info in group section `%s'\n"), name);
6005               continue;
6006             }
6007
6008           sym = symtab + section->sh_info;
6009
6010           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6011             {
6012               if (sym->st_shndx == 0
6013                   || sym->st_shndx >= elf_header.e_shnum)
6014                 {
6015                   error (_("Bad sh_info in group section `%s'\n"), name);
6016                   continue;
6017                 }
6018
6019               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6020               strtab_sec = NULL;
6021               if (strtab)
6022                 free (strtab);
6023               strtab = NULL;
6024               strtab_size = 0;
6025             }
6026           else
6027             {
6028               /* Get the string table.  */
6029               if (symtab_sec->sh_link >= elf_header.e_shnum)
6030                 {
6031                   strtab_sec = NULL;
6032                   if (strtab)
6033                     free (strtab);
6034                   strtab = NULL;
6035                   strtab_size = 0;
6036                 }
6037               else if (strtab_sec
6038                        != (sec = section_headers + symtab_sec->sh_link))
6039                 {
6040                   strtab_sec = sec;
6041                   if (strtab)
6042                     free (strtab);
6043
6044                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6045                                               1, strtab_sec->sh_size,
6046                                               _("string table"));
6047                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6048                 }
6049               group_name = sym->st_name < strtab_size
6050                 ? strtab + sym->st_name : _("<corrupt>");
6051             }
6052
6053           /* PR 17531: file: loop.  */
6054           if (section->sh_entsize > section->sh_size)
6055             {
6056               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6057                      printable_section_name (section),
6058                      (unsigned long) section->sh_entsize,
6059                      (unsigned long) section->sh_size);
6060               break;
6061             }
6062
6063           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6064                                               1, section->sh_size,
6065                                               _("section data"));
6066           if (start == NULL)
6067             continue;
6068
6069           indices = start;
6070           size = (section->sh_size / section->sh_entsize) - 1;
6071           entry = byte_get (indices, 4);
6072           indices += 4;
6073
6074           if (do_section_groups)
6075             {
6076               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6077                       get_group_flags (entry), i, name, group_name, size);
6078
6079               printf (_("   [Index]    Name\n"));
6080             }
6081
6082           group->group_index = i;
6083
6084           for (j = 0; j < size; j++)
6085             {
6086               struct group_list * g;
6087
6088               entry = byte_get (indices, 4);
6089               indices += 4;
6090
6091               if (entry >= elf_header.e_shnum)
6092                 {
6093                   static unsigned num_group_errors = 0;
6094
6095                   if (num_group_errors ++ < 10)
6096                     {
6097                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6098                              entry, i, elf_header.e_shnum - 1);
6099                       if (num_group_errors == 10)
6100                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6101                     }
6102                   continue;
6103                 }
6104
6105               if (section_headers_groups [entry] != NULL)
6106                 {
6107                   if (entry)
6108                     {
6109                       static unsigned num_errs = 0;
6110
6111                       if (num_errs ++ < 10)
6112                         {
6113                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6114                                  entry, i,
6115                                  section_headers_groups [entry]->group_index);
6116                           if (num_errs == 10)
6117                             warn (_("Further error messages about already contained group sections suppressed\n"));
6118                         }
6119                       continue;
6120                     }
6121                   else
6122                     {
6123                       /* Intel C/C++ compiler may put section 0 in a
6124                          section group. We just warn it the first time
6125                          and ignore it afterwards.  */
6126                       static int warned = 0;
6127                       if (!warned)
6128                         {
6129                           error (_("section 0 in group section [%5u]\n"),
6130                                  section_headers_groups [entry]->group_index);
6131                           warned++;
6132                         }
6133                     }
6134                 }
6135
6136               section_headers_groups [entry] = group;
6137
6138               if (do_section_groups)
6139                 {
6140                   sec = section_headers + entry;
6141                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6142                 }
6143
6144               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6145               g->section_index = entry;
6146               g->next = group->root;
6147               group->root = g;
6148             }
6149
6150           if (start)
6151             free (start);
6152
6153           group++;
6154         }
6155     }
6156
6157   if (symtab)
6158     free (symtab);
6159   if (strtab)
6160     free (strtab);
6161   return 1;
6162 }
6163
6164 /* Data used to display dynamic fixups.  */
6165
6166 struct ia64_vms_dynfixup
6167 {
6168   bfd_vma needed_ident;         /* Library ident number.  */
6169   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6170   bfd_vma fixup_needed;         /* Index of the library.  */
6171   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6172   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6173 };
6174
6175 /* Data used to display dynamic relocations.  */
6176
6177 struct ia64_vms_dynimgrela
6178 {
6179   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6180   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6181 };
6182
6183 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6184    library).  */
6185
6186 static void
6187 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6188                               const char *strtab, unsigned int strtab_sz)
6189 {
6190   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6191   long i;
6192   const char *lib_name;
6193
6194   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6195                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6196                    _("dynamic section image fixups"));
6197   if (!imfs)
6198     return;
6199
6200   if (fixup->needed < strtab_sz)
6201     lib_name = strtab + fixup->needed;
6202   else
6203     {
6204       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6205             (unsigned long) fixup->needed);
6206       lib_name = "???";
6207     }
6208   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6209           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6210   printf
6211     (_("Seg Offset           Type                             SymVec DataType\n"));
6212
6213   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6214     {
6215       unsigned int type;
6216       const char *rtype;
6217
6218       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6219       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6220       type = BYTE_GET (imfs [i].type);
6221       rtype = elf_ia64_reloc_type (type);
6222       if (rtype == NULL)
6223         printf (" 0x%08x                       ", type);
6224       else
6225         printf (" %-32s ", rtype);
6226       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6227       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6228     }
6229
6230   free (imfs);
6231 }
6232
6233 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6234
6235 static void
6236 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6237 {
6238   Elf64_External_VMS_IMAGE_RELA *imrs;
6239   long i;
6240
6241   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6242                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6243                    _("dynamic section image relocations"));
6244   if (!imrs)
6245     return;
6246
6247   printf (_("\nImage relocs\n"));
6248   printf
6249     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6250
6251   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6252     {
6253       unsigned int type;
6254       const char *rtype;
6255
6256       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6257       printf ("%08" BFD_VMA_FMT "x ",
6258               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6259       type = BYTE_GET (imrs [i].type);
6260       rtype = elf_ia64_reloc_type (type);
6261       if (rtype == NULL)
6262         printf ("0x%08x                      ", type);
6263       else
6264         printf ("%-31s ", rtype);
6265       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6266       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6267       printf ("%08" BFD_VMA_FMT "x\n",
6268               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6269     }
6270
6271   free (imrs);
6272 }
6273
6274 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6275
6276 static int
6277 process_ia64_vms_dynamic_relocs (FILE *file)
6278 {
6279   struct ia64_vms_dynfixup fixup;
6280   struct ia64_vms_dynimgrela imgrela;
6281   Elf_Internal_Dyn *entry;
6282   int res = 0;
6283   bfd_vma strtab_off = 0;
6284   bfd_vma strtab_sz = 0;
6285   char *strtab = NULL;
6286
6287   memset (&fixup, 0, sizeof (fixup));
6288   memset (&imgrela, 0, sizeof (imgrela));
6289
6290   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6291   for (entry = dynamic_section;
6292        entry < dynamic_section + dynamic_nent;
6293        entry++)
6294     {
6295       switch (entry->d_tag)
6296         {
6297         case DT_IA_64_VMS_STRTAB_OFFSET:
6298           strtab_off = entry->d_un.d_val;
6299           break;
6300         case DT_STRSZ:
6301           strtab_sz = entry->d_un.d_val;
6302           if (strtab == NULL)
6303             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6304                                1, strtab_sz, _("dynamic string section"));
6305           break;
6306
6307         case DT_IA_64_VMS_NEEDED_IDENT:
6308           fixup.needed_ident = entry->d_un.d_val;
6309           break;
6310         case DT_NEEDED:
6311           fixup.needed = entry->d_un.d_val;
6312           break;
6313         case DT_IA_64_VMS_FIXUP_NEEDED:
6314           fixup.fixup_needed = entry->d_un.d_val;
6315           break;
6316         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6317           fixup.fixup_rela_cnt = entry->d_un.d_val;
6318           break;
6319         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6320           fixup.fixup_rela_off = entry->d_un.d_val;
6321           res++;
6322           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6323           break;
6324
6325         case DT_IA_64_VMS_IMG_RELA_CNT:
6326           imgrela.img_rela_cnt = entry->d_un.d_val;
6327           break;
6328         case DT_IA_64_VMS_IMG_RELA_OFF:
6329           imgrela.img_rela_off = entry->d_un.d_val;
6330           res++;
6331           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6332           break;
6333
6334         default:
6335           break;
6336         }
6337     }
6338
6339   if (strtab != NULL)
6340     free (strtab);
6341
6342   return res;
6343 }
6344
6345 static struct
6346 {
6347   const char * name;
6348   int reloc;
6349   int size;
6350   int rela;
6351 } dynamic_relocations [] =
6352 {
6353     { "REL", DT_REL, DT_RELSZ, FALSE },
6354     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6355     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6356 };
6357
6358 /* Process the reloc section.  */
6359
6360 static int
6361 process_relocs (FILE * file)
6362 {
6363   unsigned long rel_size;
6364   unsigned long rel_offset;
6365
6366
6367   if (!do_reloc)
6368     return 1;
6369
6370   if (do_using_dynamic)
6371     {
6372       int is_rela;
6373       const char * name;
6374       int has_dynamic_reloc;
6375       unsigned int i;
6376
6377       has_dynamic_reloc = 0;
6378
6379       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6380         {
6381           is_rela = dynamic_relocations [i].rela;
6382           name = dynamic_relocations [i].name;
6383           rel_size = dynamic_info [dynamic_relocations [i].size];
6384           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6385
6386           has_dynamic_reloc |= rel_size;
6387
6388           if (is_rela == UNKNOWN)
6389             {
6390               if (dynamic_relocations [i].reloc == DT_JMPREL)
6391                 switch (dynamic_info[DT_PLTREL])
6392                   {
6393                   case DT_REL:
6394                     is_rela = FALSE;
6395                     break;
6396                   case DT_RELA:
6397                     is_rela = TRUE;
6398                     break;
6399                   }
6400             }
6401
6402           if (rel_size)
6403             {
6404               printf
6405                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6406                  name, rel_offset, rel_size);
6407
6408               dump_relocations (file,
6409                                 offset_from_vma (file, rel_offset, rel_size),
6410                                 rel_size,
6411                                 dynamic_symbols, num_dynamic_syms,
6412                                 dynamic_strings, dynamic_strings_length,
6413                                 is_rela, 1);
6414             }
6415         }
6416
6417       if (is_ia64_vms ())
6418         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6419
6420       if (! has_dynamic_reloc)
6421         printf (_("\nThere are no dynamic relocations in this file.\n"));
6422     }
6423   else
6424     {
6425       Elf_Internal_Shdr * section;
6426       unsigned long i;
6427       int found = 0;
6428
6429       for (i = 0, section = section_headers;
6430            i < elf_header.e_shnum;
6431            i++, section++)
6432         {
6433           if (   section->sh_type != SHT_RELA
6434               && section->sh_type != SHT_REL)
6435             continue;
6436
6437           rel_offset = section->sh_offset;
6438           rel_size   = section->sh_size;
6439
6440           if (rel_size)
6441             {
6442               Elf_Internal_Shdr * strsec;
6443               int is_rela;
6444
6445               printf (_("\nRelocation section "));
6446
6447               if (string_table == NULL)
6448                 printf ("%d", section->sh_name);
6449               else
6450                 printf ("'%s'", printable_section_name (section));
6451
6452               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6453                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6454
6455               is_rela = section->sh_type == SHT_RELA;
6456
6457               if (section->sh_link != 0
6458                   && section->sh_link < elf_header.e_shnum)
6459                 {
6460                   Elf_Internal_Shdr * symsec;
6461                   Elf_Internal_Sym *  symtab;
6462                   unsigned long nsyms;
6463                   unsigned long strtablen = 0;
6464                   char * strtab = NULL;
6465
6466                   symsec = section_headers + section->sh_link;
6467                   if (symsec->sh_type != SHT_SYMTAB
6468                       && symsec->sh_type != SHT_DYNSYM)
6469                     continue;
6470
6471                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6472
6473                   if (symtab == NULL)
6474                     continue;
6475
6476                   if (symsec->sh_link != 0
6477                       && symsec->sh_link < elf_header.e_shnum)
6478                     {
6479                       strsec = section_headers + symsec->sh_link;
6480
6481                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6482                                                   1, strsec->sh_size,
6483                                                   _("string table"));
6484                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6485                     }
6486
6487                   dump_relocations (file, rel_offset, rel_size,
6488                                     symtab, nsyms, strtab, strtablen,
6489                                     is_rela,
6490                                     symsec->sh_type == SHT_DYNSYM);
6491                   if (strtab)
6492                     free (strtab);
6493                   free (symtab);
6494                 }
6495               else
6496                 dump_relocations (file, rel_offset, rel_size,
6497                                   NULL, 0, NULL, 0, is_rela, 0);
6498
6499               found = 1;
6500             }
6501         }
6502
6503       if (! found)
6504         printf (_("\nThere are no relocations in this file.\n"));
6505     }
6506
6507   return 1;
6508 }
6509
6510 /* An absolute address consists of a section and an offset.  If the
6511    section is NULL, the offset itself is the address, otherwise, the
6512    address equals to LOAD_ADDRESS(section) + offset.  */
6513
6514 struct absaddr
6515 {
6516   unsigned short section;
6517   bfd_vma offset;
6518 };
6519
6520 #define ABSADDR(a) \
6521   ((a).section \
6522    ? section_headers [(a).section].sh_addr + (a).offset \
6523    : (a).offset)
6524
6525 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6526    name, if found, and the offset from the symbol to ADDR.  */
6527
6528 static void
6529 find_symbol_for_address (Elf_Internal_Sym * symtab,
6530                          unsigned long      nsyms,
6531                          const char *       strtab,
6532                          unsigned long      strtab_size,
6533                          struct absaddr     addr,
6534                          const char **      symname,
6535                          bfd_vma *          offset)
6536 {
6537   bfd_vma dist = 0x100000;
6538   Elf_Internal_Sym * sym;
6539   Elf_Internal_Sym * beg;
6540   Elf_Internal_Sym * end;
6541   Elf_Internal_Sym * best = NULL;
6542
6543   REMOVE_ARCH_BITS (addr.offset);
6544   beg = symtab;
6545   end = symtab + nsyms;
6546
6547   while (beg < end)
6548     {
6549       bfd_vma value;
6550
6551       sym = beg + (end - beg) / 2;
6552
6553       value = sym->st_value;
6554       REMOVE_ARCH_BITS (value);
6555
6556       if (sym->st_name != 0
6557           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6558           && addr.offset >= value
6559           && addr.offset - value < dist)
6560         {
6561           best = sym;
6562           dist = addr.offset - value;
6563           if (!dist)
6564             break;
6565         }
6566
6567       if (addr.offset < value)
6568         end = sym;
6569       else
6570         beg = sym + 1;
6571     }
6572
6573   if (best)
6574     {
6575       *symname = (best->st_name >= strtab_size
6576                   ? _("<corrupt>") : strtab + best->st_name);
6577       *offset = dist;
6578       return;
6579     }
6580
6581   *symname = NULL;
6582   *offset = addr.offset;
6583 }
6584
6585 static int
6586 symcmp (const void *p, const void *q)
6587 {
6588   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6589   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6590
6591   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6592 }
6593
6594 /* Process the unwind section.  */
6595
6596 #include "unwind-ia64.h"
6597
6598 struct ia64_unw_table_entry
6599 {
6600   struct absaddr start;
6601   struct absaddr end;
6602   struct absaddr info;
6603 };
6604
6605 struct ia64_unw_aux_info
6606 {
6607   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6608   unsigned long table_len;              /* Length of unwind table.  */
6609   unsigned char * info;                 /* Unwind info.  */
6610   unsigned long info_size;              /* Size of unwind info.  */
6611   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6612   bfd_vma seg_base;                     /* Starting address of segment.  */
6613   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6614   unsigned long nsyms;                  /* Number of symbols.  */
6615   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6616   unsigned long nfuns;                  /* Number of entries in funtab.  */
6617   char * strtab;                        /* The string table.  */
6618   unsigned long strtab_size;            /* Size of string table.  */
6619 };
6620
6621 static void
6622 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6623 {
6624   struct ia64_unw_table_entry * tp;
6625   unsigned long j, nfuns;
6626   int in_body;
6627
6628   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6629   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6630     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6631       aux->funtab[nfuns++] = aux->symtab[j];
6632   aux->nfuns = nfuns;
6633   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6634
6635   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6636     {
6637       bfd_vma stamp;
6638       bfd_vma offset;
6639       const unsigned char * dp;
6640       const unsigned char * head;
6641       const unsigned char * end;
6642       const char * procname;
6643
6644       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6645                                aux->strtab_size, tp->start, &procname, &offset);
6646
6647       fputs ("\n<", stdout);
6648
6649       if (procname)
6650         {
6651           fputs (procname, stdout);
6652
6653           if (offset)
6654             printf ("+%lx", (unsigned long) offset);
6655         }
6656
6657       fputs (">: [", stdout);
6658       print_vma (tp->start.offset, PREFIX_HEX);
6659       fputc ('-', stdout);
6660       print_vma (tp->end.offset, PREFIX_HEX);
6661       printf ("], info at +0x%lx\n",
6662               (unsigned long) (tp->info.offset - aux->seg_base));
6663
6664       /* PR 17531: file: 86232b32.  */
6665       if (aux->info == NULL)
6666         continue;
6667
6668       /* PR 17531: file: 0997b4d1.  */
6669       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6670         {
6671           warn (_("Invalid offset %lx in table entry %ld\n"),
6672                 (long) tp->info.offset, (long) (tp - aux->table));
6673           continue;
6674         }
6675
6676       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6677       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6678
6679       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6680               (unsigned) UNW_VER (stamp),
6681               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6682               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6683               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6684               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6685
6686       if (UNW_VER (stamp) != 1)
6687         {
6688           printf (_("\tUnknown version.\n"));
6689           continue;
6690         }
6691
6692       in_body = 0;
6693       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6694       /* PR 17531: file: 16ceda89.  */
6695       if (end > aux->info + aux->info_size)
6696         end = aux->info + aux->info_size;
6697       for (dp = head + 8; dp < end;)
6698         dp = unw_decode (dp, in_body, & in_body);
6699     }
6700
6701   free (aux->funtab);
6702 }
6703
6704 static bfd_boolean
6705 slurp_ia64_unwind_table (FILE * file,
6706                          struct ia64_unw_aux_info * aux,
6707                          Elf_Internal_Shdr * sec)
6708 {
6709   unsigned long size, nrelas, i;
6710   Elf_Internal_Phdr * seg;
6711   struct ia64_unw_table_entry * tep;
6712   Elf_Internal_Shdr * relsec;
6713   Elf_Internal_Rela * rela;
6714   Elf_Internal_Rela * rp;
6715   unsigned char * table;
6716   unsigned char * tp;
6717   Elf_Internal_Sym * sym;
6718   const char * relname;
6719
6720   aux->table_len = 0;
6721
6722   /* First, find the starting address of the segment that includes
6723      this section: */
6724
6725   if (elf_header.e_phnum)
6726     {
6727       if (! get_program_headers (file))
6728           return FALSE;
6729
6730       for (seg = program_headers;
6731            seg < program_headers + elf_header.e_phnum;
6732            ++seg)
6733         {
6734           if (seg->p_type != PT_LOAD)
6735             continue;
6736
6737           if (sec->sh_addr >= seg->p_vaddr
6738               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6739             {
6740               aux->seg_base = seg->p_vaddr;
6741               break;
6742             }
6743         }
6744     }
6745
6746   /* Second, build the unwind table from the contents of the unwind section:  */
6747   size = sec->sh_size;
6748   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6749                                       _("unwind table"));
6750   if (!table)
6751     return FALSE;
6752
6753   aux->table_len = size / (3 * eh_addr_size);
6754   aux->table = (struct ia64_unw_table_entry *)
6755     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6756   tep = aux->table;
6757
6758   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6759     {
6760       tep->start.section = SHN_UNDEF;
6761       tep->end.section   = SHN_UNDEF;
6762       tep->info.section  = SHN_UNDEF;
6763       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6764       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6765       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6766       tep->start.offset += aux->seg_base;
6767       tep->end.offset   += aux->seg_base;
6768       tep->info.offset  += aux->seg_base;
6769     }
6770   free (table);
6771
6772   /* Third, apply any relocations to the unwind table:  */
6773   for (relsec = section_headers;
6774        relsec < section_headers + elf_header.e_shnum;
6775        ++relsec)
6776     {
6777       if (relsec->sh_type != SHT_RELA
6778           || relsec->sh_info >= elf_header.e_shnum
6779           || section_headers + relsec->sh_info != sec)
6780         continue;
6781
6782       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6783                               & rela, & nrelas))
6784         {
6785           free (aux->table);
6786           aux->table = NULL;
6787           aux->table_len = 0;
6788           return FALSE;
6789         }
6790
6791       for (rp = rela; rp < rela + nrelas; ++rp)
6792         {
6793           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6794           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6795
6796           /* PR 17531: file: 9fa67536.  */
6797           if (relname == NULL)
6798             {
6799               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6800               continue;
6801             }
6802
6803           if (! const_strneq (relname, "R_IA64_SEGREL"))
6804             {
6805               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6806               continue;
6807             }
6808
6809           i = rp->r_offset / (3 * eh_addr_size);
6810
6811           /* PR 17531: file: 5bc8d9bf.  */
6812           if (i >= aux->table_len)
6813             {
6814               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6815               continue;
6816             }
6817
6818           switch (rp->r_offset / eh_addr_size % 3)
6819             {
6820             case 0:
6821               aux->table[i].start.section = sym->st_shndx;
6822               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6823               break;
6824             case 1:
6825               aux->table[i].end.section   = sym->st_shndx;
6826               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6827               break;
6828             case 2:
6829               aux->table[i].info.section  = sym->st_shndx;
6830               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6831               break;
6832             default:
6833               break;
6834             }
6835         }
6836
6837       free (rela);
6838     }
6839
6840   return TRUE;
6841 }
6842
6843 static void
6844 ia64_process_unwind (FILE * file)
6845 {
6846   Elf_Internal_Shdr * sec;
6847   Elf_Internal_Shdr * unwsec = NULL;
6848   Elf_Internal_Shdr * strsec;
6849   unsigned long i, unwcount = 0, unwstart = 0;
6850   struct ia64_unw_aux_info aux;
6851
6852   memset (& aux, 0, sizeof (aux));
6853
6854   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6855     {
6856       if (sec->sh_type == SHT_SYMTAB
6857           && sec->sh_link < elf_header.e_shnum)
6858         {
6859           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6860
6861           strsec = section_headers + sec->sh_link;
6862           if (aux.strtab != NULL)
6863             {
6864               error (_("Multiple auxillary string tables encountered\n"));
6865               free (aux.strtab);
6866             }
6867           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6868                                           1, strsec->sh_size,
6869                                           _("string table"));
6870           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6871         }
6872       else if (sec->sh_type == SHT_IA_64_UNWIND)
6873         unwcount++;
6874     }
6875
6876   if (!unwcount)
6877     printf (_("\nThere are no unwind sections in this file.\n"));
6878
6879   while (unwcount-- > 0)
6880     {
6881       char * suffix;
6882       size_t len, len2;
6883
6884       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6885            i < elf_header.e_shnum; ++i, ++sec)
6886         if (sec->sh_type == SHT_IA_64_UNWIND)
6887           {
6888             unwsec = sec;
6889             break;
6890           }
6891       /* We have already counted the number of SHT_IA64_UNWIND
6892          sections so the loop above should never fail.  */
6893       assert (unwsec != NULL);
6894
6895       unwstart = i + 1;
6896       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6897
6898       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6899         {
6900           /* We need to find which section group it is in.  */
6901           struct group_list * g;
6902
6903           if (section_headers_groups == NULL
6904               || section_headers_groups [i] == NULL)
6905             i = elf_header.e_shnum;
6906           else
6907             {
6908               g = section_headers_groups [i]->root;
6909
6910               for (; g != NULL; g = g->next)
6911                 {
6912                   sec = section_headers + g->section_index;
6913
6914                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6915                     break;
6916                 }
6917
6918               if (g == NULL)
6919                 i = elf_header.e_shnum;
6920             }
6921         }
6922       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6923         {
6924           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6925           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6926           suffix = SECTION_NAME (unwsec) + len;
6927           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6928                ++i, ++sec)
6929             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6930                 && streq (SECTION_NAME (sec) + len2, suffix))
6931               break;
6932         }
6933       else
6934         {
6935           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6936              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6937           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6938           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6939           suffix = "";
6940           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6941             suffix = SECTION_NAME (unwsec) + len;
6942           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6943                ++i, ++sec)
6944             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6945                 && streq (SECTION_NAME (sec) + len2, suffix))
6946               break;
6947         }
6948
6949       if (i == elf_header.e_shnum)
6950         {
6951           printf (_("\nCould not find unwind info section for "));
6952
6953           if (string_table == NULL)
6954             printf ("%d", unwsec->sh_name);
6955           else
6956             printf ("'%s'", printable_section_name (unwsec));
6957         }
6958       else
6959         {
6960           aux.info_addr = sec->sh_addr;
6961           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6962                                                  sec->sh_size,
6963                                                  _("unwind info"));
6964           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6965
6966           printf (_("\nUnwind section "));
6967
6968           if (string_table == NULL)
6969             printf ("%d", unwsec->sh_name);
6970           else
6971             printf ("'%s'", printable_section_name (unwsec));
6972
6973           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6974                   (unsigned long) unwsec->sh_offset,
6975                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6976
6977           if (slurp_ia64_unwind_table (file, & aux, unwsec)
6978               && aux.table_len > 0)
6979             dump_ia64_unwind (& aux);
6980
6981           if (aux.table)
6982             free ((char *) aux.table);
6983           if (aux.info)
6984             free ((char *) aux.info);
6985           aux.table = NULL;
6986           aux.info = NULL;
6987         }
6988     }
6989
6990   if (aux.symtab)
6991     free (aux.symtab);
6992   if (aux.strtab)
6993     free ((char *) aux.strtab);
6994 }
6995
6996 struct hppa_unw_table_entry
6997   {
6998     struct absaddr start;
6999     struct absaddr end;
7000     unsigned int Cannot_unwind:1;               /* 0 */
7001     unsigned int Millicode:1;                   /* 1 */
7002     unsigned int Millicode_save_sr0:1;          /* 2 */
7003     unsigned int Region_description:2;          /* 3..4 */
7004     unsigned int reserved1:1;                   /* 5 */
7005     unsigned int Entry_SR:1;                    /* 6 */
7006     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7007     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7008     unsigned int Args_stored:1;                 /* 16 */
7009     unsigned int Variable_Frame:1;              /* 17 */
7010     unsigned int Separate_Package_Body:1;       /* 18 */
7011     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7012     unsigned int Stack_Overflow_Check:1;        /* 20 */
7013     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7014     unsigned int Ada_Region:1;                  /* 22 */
7015     unsigned int cxx_info:1;                    /* 23 */
7016     unsigned int cxx_try_catch:1;               /* 24 */
7017     unsigned int sched_entry_seq:1;             /* 25 */
7018     unsigned int reserved2:1;                   /* 26 */
7019     unsigned int Save_SP:1;                     /* 27 */
7020     unsigned int Save_RP:1;                     /* 28 */
7021     unsigned int Save_MRP_in_frame:1;           /* 29 */
7022     unsigned int extn_ptr_defined:1;            /* 30 */
7023     unsigned int Cleanup_defined:1;             /* 31 */
7024
7025     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7026     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7027     unsigned int Large_frame:1;                 /* 2 */
7028     unsigned int Pseudo_SP_Set:1;               /* 3 */
7029     unsigned int reserved4:1;                   /* 4 */
7030     unsigned int Total_frame_size:27;           /* 5..31 */
7031   };
7032
7033 struct hppa_unw_aux_info
7034 {
7035   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7036   unsigned long table_len;              /* Length of unwind table.  */
7037   bfd_vma seg_base;                     /* Starting address of segment.  */
7038   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7039   unsigned long nsyms;                  /* Number of symbols.  */
7040   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7041   unsigned long nfuns;                  /* Number of entries in funtab.  */
7042   char * strtab;                        /* The string table.  */
7043   unsigned long strtab_size;            /* Size of string table.  */
7044 };
7045
7046 static void
7047 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7048 {
7049   struct hppa_unw_table_entry * tp;
7050   unsigned long j, nfuns;
7051
7052   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7053   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7054     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7055       aux->funtab[nfuns++] = aux->symtab[j];
7056   aux->nfuns = nfuns;
7057   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7058
7059   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7060     {
7061       bfd_vma offset;
7062       const char * procname;
7063
7064       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7065                                aux->strtab_size, tp->start, &procname,
7066                                &offset);
7067
7068       fputs ("\n<", stdout);
7069
7070       if (procname)
7071         {
7072           fputs (procname, stdout);
7073
7074           if (offset)
7075             printf ("+%lx", (unsigned long) offset);
7076         }
7077
7078       fputs (">: [", stdout);
7079       print_vma (tp->start.offset, PREFIX_HEX);
7080       fputc ('-', stdout);
7081       print_vma (tp->end.offset, PREFIX_HEX);
7082       printf ("]\n\t");
7083
7084 #define PF(_m) if (tp->_m) printf (#_m " ");
7085 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7086       PF(Cannot_unwind);
7087       PF(Millicode);
7088       PF(Millicode_save_sr0);
7089       /* PV(Region_description);  */
7090       PF(Entry_SR);
7091       PV(Entry_FR);
7092       PV(Entry_GR);
7093       PF(Args_stored);
7094       PF(Variable_Frame);
7095       PF(Separate_Package_Body);
7096       PF(Frame_Extension_Millicode);
7097       PF(Stack_Overflow_Check);
7098       PF(Two_Instruction_SP_Increment);
7099       PF(Ada_Region);
7100       PF(cxx_info);
7101       PF(cxx_try_catch);
7102       PF(sched_entry_seq);
7103       PF(Save_SP);
7104       PF(Save_RP);
7105       PF(Save_MRP_in_frame);
7106       PF(extn_ptr_defined);
7107       PF(Cleanup_defined);
7108       PF(MPE_XL_interrupt_marker);
7109       PF(HP_UX_interrupt_marker);
7110       PF(Large_frame);
7111       PF(Pseudo_SP_Set);
7112       PV(Total_frame_size);
7113 #undef PF
7114 #undef PV
7115     }
7116
7117   printf ("\n");
7118
7119   free (aux->funtab);
7120 }
7121
7122 static int
7123 slurp_hppa_unwind_table (FILE * file,
7124                          struct hppa_unw_aux_info * aux,
7125                          Elf_Internal_Shdr * sec)
7126 {
7127   unsigned long size, unw_ent_size, nentries, nrelas, i;
7128   Elf_Internal_Phdr * seg;
7129   struct hppa_unw_table_entry * tep;
7130   Elf_Internal_Shdr * relsec;
7131   Elf_Internal_Rela * rela;
7132   Elf_Internal_Rela * rp;
7133   unsigned char * table;
7134   unsigned char * tp;
7135   Elf_Internal_Sym * sym;
7136   const char * relname;
7137
7138   /* First, find the starting address of the segment that includes
7139      this section.  */
7140
7141   if (elf_header.e_phnum)
7142     {
7143       if (! get_program_headers (file))
7144         return 0;
7145
7146       for (seg = program_headers;
7147            seg < program_headers + elf_header.e_phnum;
7148            ++seg)
7149         {
7150           if (seg->p_type != PT_LOAD)
7151             continue;
7152
7153           if (sec->sh_addr >= seg->p_vaddr
7154               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7155             {
7156               aux->seg_base = seg->p_vaddr;
7157               break;
7158             }
7159         }
7160     }
7161
7162   /* Second, build the unwind table from the contents of the unwind
7163      section.  */
7164   size = sec->sh_size;
7165   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7166                                       _("unwind table"));
7167   if (!table)
7168     return 0;
7169
7170   unw_ent_size = 16;
7171   nentries = size / unw_ent_size;
7172   size = unw_ent_size * nentries;
7173
7174   tep = aux->table = (struct hppa_unw_table_entry *)
7175       xcmalloc (nentries, sizeof (aux->table[0]));
7176
7177   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7178     {
7179       unsigned int tmp1, tmp2;
7180
7181       tep->start.section = SHN_UNDEF;
7182       tep->end.section   = SHN_UNDEF;
7183
7184       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7185       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7186       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7187       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7188
7189       tep->start.offset += aux->seg_base;
7190       tep->end.offset   += aux->seg_base;
7191
7192       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7193       tep->Millicode = (tmp1 >> 30) & 0x1;
7194       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7195       tep->Region_description = (tmp1 >> 27) & 0x3;
7196       tep->reserved1 = (tmp1 >> 26) & 0x1;
7197       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7198       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7199       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7200       tep->Args_stored = (tmp1 >> 15) & 0x1;
7201       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7202       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7203       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7204       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7205       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7206       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7207       tep->cxx_info = (tmp1 >> 8) & 0x1;
7208       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7209       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7210       tep->reserved2 = (tmp1 >> 5) & 0x1;
7211       tep->Save_SP = (tmp1 >> 4) & 0x1;
7212       tep->Save_RP = (tmp1 >> 3) & 0x1;
7213       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7214       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7215       tep->Cleanup_defined = tmp1 & 0x1;
7216
7217       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7218       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7219       tep->Large_frame = (tmp2 >> 29) & 0x1;
7220       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7221       tep->reserved4 = (tmp2 >> 27) & 0x1;
7222       tep->Total_frame_size = tmp2 & 0x7ffffff;
7223     }
7224   free (table);
7225
7226   /* Third, apply any relocations to the unwind table.  */
7227   for (relsec = section_headers;
7228        relsec < section_headers + elf_header.e_shnum;
7229        ++relsec)
7230     {
7231       if (relsec->sh_type != SHT_RELA
7232           || relsec->sh_info >= elf_header.e_shnum
7233           || section_headers + relsec->sh_info != sec)
7234         continue;
7235
7236       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7237                               & rela, & nrelas))
7238         return 0;
7239
7240       for (rp = rela; rp < rela + nrelas; ++rp)
7241         {
7242           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7243           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7244
7245           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7246           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7247             {
7248               warn (_("Skipping unexpected relocation type %s\n"), relname);
7249               continue;
7250             }
7251
7252           i = rp->r_offset / unw_ent_size;
7253
7254           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7255             {
7256             case 0:
7257               aux->table[i].start.section = sym->st_shndx;
7258               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7259               break;
7260             case 1:
7261               aux->table[i].end.section   = sym->st_shndx;
7262               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7263               break;
7264             default:
7265               break;
7266             }
7267         }
7268
7269       free (rela);
7270     }
7271
7272   aux->table_len = nentries;
7273
7274   return 1;
7275 }
7276
7277 static void
7278 hppa_process_unwind (FILE * file)
7279 {
7280   struct hppa_unw_aux_info aux;
7281   Elf_Internal_Shdr * unwsec = NULL;
7282   Elf_Internal_Shdr * strsec;
7283   Elf_Internal_Shdr * sec;
7284   unsigned long i;
7285
7286   if (string_table == NULL)
7287     return;
7288
7289   memset (& aux, 0, sizeof (aux));
7290
7291   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7292     {
7293       if (sec->sh_type == SHT_SYMTAB
7294           && sec->sh_link < elf_header.e_shnum)
7295         {
7296           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7297
7298           strsec = section_headers + sec->sh_link;
7299           if (aux.strtab != NULL)
7300             {
7301               error (_("Multiple auxillary string tables encountered\n"));
7302               free (aux.strtab);
7303             }
7304           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7305                                           1, strsec->sh_size,
7306                                           _("string table"));
7307           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7308         }
7309       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7310         unwsec = sec;
7311     }
7312
7313   if (!unwsec)
7314     printf (_("\nThere are no unwind sections in this file.\n"));
7315
7316   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7317     {
7318       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7319         {
7320           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7321                   printable_section_name (sec),
7322                   (unsigned long) sec->sh_offset,
7323                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7324
7325           slurp_hppa_unwind_table (file, &aux, sec);
7326           if (aux.table_len > 0)
7327             dump_hppa_unwind (&aux);
7328
7329           if (aux.table)
7330             free ((char *) aux.table);
7331           aux.table = NULL;
7332         }
7333     }
7334
7335   if (aux.symtab)
7336     free (aux.symtab);
7337   if (aux.strtab)
7338     free ((char *) aux.strtab);
7339 }
7340
7341 struct arm_section
7342 {
7343   unsigned char *      data;            /* The unwind data.  */
7344   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7345   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7346   unsigned long        nrelas;          /* The number of relocations.  */
7347   unsigned int         rel_type;        /* REL or RELA ?  */
7348   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7349 };
7350
7351 struct arm_unw_aux_info
7352 {
7353   FILE *              file;             /* The file containing the unwind sections.  */
7354   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7355   unsigned long       nsyms;            /* Number of symbols.  */
7356   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7357   unsigned long       nfuns;            /* Number of these symbols.  */
7358   char *              strtab;           /* The file's string table.  */
7359   unsigned long       strtab_size;      /* Size of string table.  */
7360 };
7361
7362 static const char *
7363 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7364                         bfd_vma fn, struct absaddr addr)
7365 {
7366   const char *procname;
7367   bfd_vma sym_offset;
7368
7369   if (addr.section == SHN_UNDEF)
7370     addr.offset = fn;
7371
7372   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7373                            aux->strtab_size, addr, &procname,
7374                            &sym_offset);
7375
7376   print_vma (fn, PREFIX_HEX);
7377
7378   if (procname)
7379     {
7380       fputs (" <", stdout);
7381       fputs (procname, stdout);
7382
7383       if (sym_offset)
7384         printf ("+0x%lx", (unsigned long) sym_offset);
7385       fputc ('>', stdout);
7386     }
7387
7388   return procname;
7389 }
7390
7391 static void
7392 arm_free_section (struct arm_section *arm_sec)
7393 {
7394   if (arm_sec->data != NULL)
7395     free (arm_sec->data);
7396
7397   if (arm_sec->rela != NULL)
7398     free (arm_sec->rela);
7399 }
7400
7401 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7402       cached section and install SEC instead.
7403    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7404       and return its valued in * WORDP, relocating if necessary.
7405    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7406       relocation's offset in ADDR.
7407    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7408       into the string table of the symbol associated with the reloc.  If no
7409       reloc was applied store -1 there.
7410    5) Return TRUE upon success, FALSE otherwise.  */
7411
7412 static bfd_boolean
7413 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7414                          struct arm_section *       arm_sec,
7415                          Elf_Internal_Shdr *        sec,
7416                          bfd_vma                    word_offset,
7417                          unsigned int *             wordp,
7418                          struct absaddr *           addr,
7419                          bfd_vma *                  sym_name)
7420 {
7421   Elf_Internal_Rela *rp;
7422   Elf_Internal_Sym *sym;
7423   const char * relname;
7424   unsigned int word;
7425   bfd_boolean wrapped;
7426
7427   if (sec == NULL || arm_sec == NULL)
7428     return FALSE;
7429
7430   addr->section = SHN_UNDEF;
7431   addr->offset = 0;
7432
7433   if (sym_name != NULL)
7434     *sym_name = (bfd_vma) -1;
7435
7436   /* If necessary, update the section cache.  */
7437   if (sec != arm_sec->sec)
7438     {
7439       Elf_Internal_Shdr *relsec;
7440
7441       arm_free_section (arm_sec);
7442
7443       arm_sec->sec = sec;
7444       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7445                                 sec->sh_size, _("unwind data"));
7446       arm_sec->rela = NULL;
7447       arm_sec->nrelas = 0;
7448
7449       for (relsec = section_headers;
7450            relsec < section_headers + elf_header.e_shnum;
7451            ++relsec)
7452         {
7453           if (relsec->sh_info >= elf_header.e_shnum
7454               || section_headers + relsec->sh_info != sec
7455               /* PR 15745: Check the section type as well.  */
7456               || (relsec->sh_type != SHT_REL
7457                   && relsec->sh_type != SHT_RELA))
7458             continue;
7459
7460           arm_sec->rel_type = relsec->sh_type;
7461           if (relsec->sh_type == SHT_REL)
7462             {
7463               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7464                                      relsec->sh_size,
7465                                      & arm_sec->rela, & arm_sec->nrelas))
7466                 return FALSE;
7467             }
7468           else /* relsec->sh_type == SHT_RELA */
7469             {
7470               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7471                                       relsec->sh_size,
7472                                       & arm_sec->rela, & arm_sec->nrelas))
7473                 return FALSE;
7474             }
7475           break;
7476         }
7477
7478       arm_sec->next_rela = arm_sec->rela;
7479     }
7480
7481   /* If there is no unwind data we can do nothing.  */
7482   if (arm_sec->data == NULL)
7483     return FALSE;
7484
7485   /* If the offset is invalid then fail.  */
7486   if (word_offset > sec->sh_size - 4)
7487     return FALSE;
7488
7489   /* Get the word at the required offset.  */
7490   word = byte_get (arm_sec->data + word_offset, 4);
7491
7492   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7493   if (arm_sec->rela == NULL)
7494     {
7495       * wordp = word;
7496       return TRUE;
7497     }
7498
7499   /* Look through the relocs to find the one that applies to the provided offset.  */
7500   wrapped = FALSE;
7501   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7502     {
7503       bfd_vma prelval, offset;
7504
7505       if (rp->r_offset > word_offset && !wrapped)
7506         {
7507           rp = arm_sec->rela;
7508           wrapped = TRUE;
7509         }
7510       if (rp->r_offset > word_offset)
7511         break;
7512
7513       if (rp->r_offset & 3)
7514         {
7515           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7516                 (unsigned long) rp->r_offset);
7517           continue;
7518         }
7519
7520       if (rp->r_offset < word_offset)
7521         continue;
7522
7523       /* PR 17531: file: 027-161405-0.004  */
7524       if (aux->symtab == NULL)
7525         continue;
7526
7527       if (arm_sec->rel_type == SHT_REL)
7528         {
7529           offset = word & 0x7fffffff;
7530           if (offset & 0x40000000)
7531             offset |= ~ (bfd_vma) 0x7fffffff;
7532         }
7533       else if (arm_sec->rel_type == SHT_RELA)
7534         offset = rp->r_addend;
7535       else
7536         {
7537           error (_("Unknown section relocation type %d encountered\n"),
7538                  arm_sec->rel_type);
7539           break;
7540         }
7541
7542       /* PR 17531 file: 027-1241568-0.004.  */
7543       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7544         {
7545           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7546                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7547           break;
7548         }
7549
7550       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7551       offset += sym->st_value;
7552       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7553
7554       /* Check that we are processing the expected reloc type.  */
7555       if (elf_header.e_machine == EM_ARM)
7556         {
7557           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7558           if (relname == NULL)
7559             {
7560               warn (_("Skipping unknown ARM relocation type: %d\n"),
7561                     (int) ELF32_R_TYPE (rp->r_info));
7562               continue;
7563             }
7564
7565           if (streq (relname, "R_ARM_NONE"))
7566               continue;
7567
7568           if (! streq (relname, "R_ARM_PREL31"))
7569             {
7570               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7571               continue;
7572             }
7573         }
7574       else if (elf_header.e_machine == EM_TI_C6000)
7575         {
7576           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7577           if (relname == NULL)
7578             {
7579               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7580                     (int) ELF32_R_TYPE (rp->r_info));
7581               continue;
7582             }
7583
7584           if (streq (relname, "R_C6000_NONE"))
7585             continue;
7586
7587           if (! streq (relname, "R_C6000_PREL31"))
7588             {
7589               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7590               continue;
7591             }
7592
7593           prelval >>= 1;
7594         }
7595       else
7596         {
7597           /* This function currently only supports ARM and TI unwinders.  */
7598           warn (_("Only TI and ARM unwinders are currently supported\n"));
7599           break;
7600         }
7601
7602       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7603       addr->section = sym->st_shndx;
7604       addr->offset = offset;
7605
7606       if (sym_name)
7607         * sym_name = sym->st_name;
7608       break;
7609     }
7610
7611   *wordp = word;
7612   arm_sec->next_rela = rp;
7613
7614   return TRUE;
7615 }
7616
7617 static const char *tic6x_unwind_regnames[16] =
7618 {
7619   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7620   "A14", "A13", "A12", "A11", "A10",
7621   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7622 };
7623
7624 static void
7625 decode_tic6x_unwind_regmask (unsigned int mask)
7626 {
7627   int i;
7628
7629   for (i = 12; mask; mask >>= 1, i--)
7630     {
7631       if (mask & 1)
7632         {
7633           fputs (tic6x_unwind_regnames[i], stdout);
7634           if (mask > 1)
7635             fputs (", ", stdout);
7636         }
7637     }
7638 }
7639
7640 #define ADVANCE                                                 \
7641   if (remaining == 0 && more_words)                             \
7642     {                                                           \
7643       data_offset += 4;                                         \
7644       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7645                                      data_offset, & word, & addr, NULL))        \
7646         return;                                                 \
7647       remaining = 4;                                            \
7648       more_words--;                                             \
7649     }                                                           \
7650
7651 #define GET_OP(OP)                      \
7652   ADVANCE;                              \
7653   if (remaining)                        \
7654     {                                   \
7655       remaining--;                      \
7656       (OP) = word >> 24;                \
7657       word <<= 8;                       \
7658     }                                   \
7659   else                                  \
7660     {                                   \
7661       printf (_("[Truncated opcode]\n"));       \
7662       return;                           \
7663     }                                   \
7664   printf ("0x%02x ", OP)
7665
7666 static void
7667 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7668                             unsigned int               word,
7669                             unsigned int               remaining,
7670                             unsigned int               more_words,
7671                             bfd_vma                    data_offset,
7672                             Elf_Internal_Shdr *        data_sec,
7673                             struct arm_section *       data_arm_sec)
7674 {
7675   struct absaddr addr;
7676
7677   /* Decode the unwinding instructions.  */
7678   while (1)
7679     {
7680       unsigned int op, op2;
7681
7682       ADVANCE;
7683       if (remaining == 0)
7684         break;
7685       remaining--;
7686       op = word >> 24;
7687       word <<= 8;
7688
7689       printf ("  0x%02x ", op);
7690
7691       if ((op & 0xc0) == 0x00)
7692         {
7693           int offset = ((op & 0x3f) << 2) + 4;
7694
7695           printf ("     vsp = vsp + %d", offset);
7696         }
7697       else if ((op & 0xc0) == 0x40)
7698         {
7699           int offset = ((op & 0x3f) << 2) + 4;
7700
7701           printf ("     vsp = vsp - %d", offset);
7702         }
7703       else if ((op & 0xf0) == 0x80)
7704         {
7705           GET_OP (op2);
7706           if (op == 0x80 && op2 == 0)
7707             printf (_("Refuse to unwind"));
7708           else
7709             {
7710               unsigned int mask = ((op & 0x0f) << 8) | op2;
7711               int first = 1;
7712               int i;
7713
7714               printf ("pop {");
7715               for (i = 0; i < 12; i++)
7716                 if (mask & (1 << i))
7717                   {
7718                     if (first)
7719                       first = 0;
7720                     else
7721                       printf (", ");
7722                     printf ("r%d", 4 + i);
7723                   }
7724               printf ("}");
7725             }
7726         }
7727       else if ((op & 0xf0) == 0x90)
7728         {
7729           if (op == 0x9d || op == 0x9f)
7730             printf (_("     [Reserved]"));
7731           else
7732             printf ("     vsp = r%d", op & 0x0f);
7733         }
7734       else if ((op & 0xf0) == 0xa0)
7735         {
7736           int end = 4 + (op & 0x07);
7737           int first = 1;
7738           int i;
7739
7740           printf ("     pop {");
7741           for (i = 4; i <= end; i++)
7742             {
7743               if (first)
7744                 first = 0;
7745               else
7746                 printf (", ");
7747               printf ("r%d", i);
7748             }
7749           if (op & 0x08)
7750             {
7751               if (!first)
7752                 printf (", ");
7753               printf ("r14");
7754             }
7755           printf ("}");
7756         }
7757       else if (op == 0xb0)
7758         printf (_("     finish"));
7759       else if (op == 0xb1)
7760         {
7761           GET_OP (op2);
7762           if (op2 == 0 || (op2 & 0xf0) != 0)
7763             printf (_("[Spare]"));
7764           else
7765             {
7766               unsigned int mask = op2 & 0x0f;
7767               int first = 1;
7768               int i;
7769
7770               printf ("pop {");
7771               for (i = 0; i < 12; i++)
7772                 if (mask & (1 << i))
7773                   {
7774                     if (first)
7775                       first = 0;
7776                     else
7777                       printf (", ");
7778                     printf ("r%d", i);
7779                   }
7780               printf ("}");
7781             }
7782         }
7783       else if (op == 0xb2)
7784         {
7785           unsigned char buf[9];
7786           unsigned int i, len;
7787           unsigned long offset;
7788
7789           for (i = 0; i < sizeof (buf); i++)
7790             {
7791               GET_OP (buf[i]);
7792               if ((buf[i] & 0x80) == 0)
7793                 break;
7794             }
7795           if (i == sizeof (buf))
7796             printf (_("corrupt change to vsp"));
7797           else
7798             {
7799               offset = read_uleb128 (buf, &len, buf + i + 1);
7800               assert (len == i + 1);
7801               offset = offset * 4 + 0x204;
7802               printf ("vsp = vsp + %ld", offset);
7803             }
7804         }
7805       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7806         {
7807           unsigned int first, last;
7808
7809           GET_OP (op2);
7810           first = op2 >> 4;
7811           last = op2 & 0x0f;
7812           if (op == 0xc8)
7813             first = first + 16;
7814           printf ("pop {D%d", first);
7815           if (last)
7816             printf ("-D%d", first + last);
7817           printf ("}");
7818         }
7819       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7820         {
7821           unsigned int count = op & 0x07;
7822
7823           printf ("pop {D8");
7824           if (count)
7825             printf ("-D%d", 8 + count);
7826           printf ("}");
7827         }
7828       else if (op >= 0xc0 && op <= 0xc5)
7829         {
7830           unsigned int count = op & 0x07;
7831
7832           printf ("     pop {wR10");
7833           if (count)
7834             printf ("-wR%d", 10 + count);
7835           printf ("}");
7836         }
7837       else if (op == 0xc6)
7838         {
7839           unsigned int first, last;
7840
7841           GET_OP (op2);
7842           first = op2 >> 4;
7843           last = op2 & 0x0f;
7844           printf ("pop {wR%d", first);
7845           if (last)
7846             printf ("-wR%d", first + last);
7847           printf ("}");
7848         }
7849       else if (op == 0xc7)
7850         {
7851           GET_OP (op2);
7852           if (op2 == 0 || (op2 & 0xf0) != 0)
7853             printf (_("[Spare]"));
7854           else
7855             {
7856               unsigned int mask = op2 & 0x0f;
7857               int first = 1;
7858               int i;
7859
7860               printf ("pop {");
7861               for (i = 0; i < 4; i++)
7862                 if (mask & (1 << i))
7863                   {
7864                     if (first)
7865                       first = 0;
7866                     else
7867                       printf (", ");
7868                     printf ("wCGR%d", i);
7869                   }
7870               printf ("}");
7871             }
7872         }
7873       else
7874         printf (_("     [unsupported opcode]"));
7875       printf ("\n");
7876     }
7877 }
7878
7879 static void
7880 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
7881                               unsigned int               word,
7882                               unsigned int               remaining,
7883                               unsigned int               more_words,
7884                               bfd_vma                    data_offset,
7885                               Elf_Internal_Shdr *        data_sec,
7886                               struct arm_section *       data_arm_sec)
7887 {
7888   struct absaddr addr;
7889
7890   /* Decode the unwinding instructions.  */
7891   while (1)
7892     {
7893       unsigned int op, op2;
7894
7895       ADVANCE;
7896       if (remaining == 0)
7897         break;
7898       remaining--;
7899       op = word >> 24;
7900       word <<= 8;
7901
7902       printf ("  0x%02x ", op);
7903
7904       if ((op & 0xc0) == 0x00)
7905         {
7906           int offset = ((op & 0x3f) << 3) + 8;
7907           printf ("     sp = sp + %d", offset);
7908         }
7909       else if ((op & 0xc0) == 0x80)
7910         {
7911           GET_OP (op2);
7912           if (op == 0x80 && op2 == 0)
7913             printf (_("Refuse to unwind"));
7914           else
7915             {
7916               unsigned int mask = ((op & 0x1f) << 8) | op2;
7917               if (op & 0x20)
7918                 printf ("pop compact {");
7919               else
7920                 printf ("pop {");
7921
7922               decode_tic6x_unwind_regmask (mask);
7923               printf("}");
7924             }
7925         }
7926       else if ((op & 0xf0) == 0xc0)
7927         {
7928           unsigned int reg;
7929           unsigned int nregs;
7930           unsigned int i;
7931           const char *name;
7932           struct
7933           {
7934               unsigned int offset;
7935               unsigned int reg;
7936           } regpos[16];
7937
7938           /* Scan entire instruction first so that GET_OP output is not
7939              interleaved with disassembly.  */
7940           nregs = 0;
7941           for (i = 0; nregs < (op & 0xf); i++)
7942             {
7943               GET_OP (op2);
7944               reg = op2 >> 4;
7945               if (reg != 0xf)
7946                 {
7947                   regpos[nregs].offset = i * 2;
7948                   regpos[nregs].reg = reg;
7949                   nregs++;
7950                 }
7951
7952               reg = op2 & 0xf;
7953               if (reg != 0xf)
7954                 {
7955                   regpos[nregs].offset = i * 2 + 1;
7956                   regpos[nregs].reg = reg;
7957                   nregs++;
7958                 }
7959             }
7960
7961           printf (_("pop frame {"));
7962           reg = nregs - 1;
7963           for (i = i * 2; i > 0; i--)
7964             {
7965               if (regpos[reg].offset == i - 1)
7966                 {
7967                   name = tic6x_unwind_regnames[regpos[reg].reg];
7968                   if (reg > 0)
7969                     reg--;
7970                 }
7971               else
7972                 name = _("[pad]");
7973
7974               fputs (name, stdout);
7975               if (i > 1)
7976                 printf (", ");
7977             }
7978
7979           printf ("}");
7980         }
7981       else if (op == 0xd0)
7982         printf ("     MOV FP, SP");
7983       else if (op == 0xd1)
7984         printf ("     __c6xabi_pop_rts");
7985       else if (op == 0xd2)
7986         {
7987           unsigned char buf[9];
7988           unsigned int i, len;
7989           unsigned long offset;
7990
7991           for (i = 0; i < sizeof (buf); i++)
7992             {
7993               GET_OP (buf[i]);
7994               if ((buf[i] & 0x80) == 0)
7995                 break;
7996             }
7997           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
7998           if (i == sizeof (buf))
7999             {
8000               printf ("<corrupt sp adjust>\n");
8001               warn (_("Corrupt stack pointer adjustment detected\n"));
8002               return;
8003             }
8004
8005           offset = read_uleb128 (buf, &len, buf + i + 1);
8006           assert (len == i + 1);
8007           offset = offset * 8 + 0x408;
8008           printf (_("sp = sp + %ld"), offset);
8009         }
8010       else if ((op & 0xf0) == 0xe0)
8011         {
8012           if ((op & 0x0f) == 7)
8013             printf ("     RETURN");
8014           else
8015             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8016         }
8017       else
8018         {
8019           printf (_("     [unsupported opcode]"));
8020         }
8021       putchar ('\n');
8022     }
8023 }
8024
8025 static bfd_vma
8026 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8027 {
8028   bfd_vma offset;
8029
8030   offset = word & 0x7fffffff;
8031   if (offset & 0x40000000)
8032     offset |= ~ (bfd_vma) 0x7fffffff;
8033
8034   if (elf_header.e_machine == EM_TI_C6000)
8035     offset <<= 1;
8036
8037   return offset + where;
8038 }
8039
8040 static void
8041 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8042                    unsigned int               word,
8043                    unsigned int               remaining,
8044                    bfd_vma                    data_offset,
8045                    Elf_Internal_Shdr *        data_sec,
8046                    struct arm_section *       data_arm_sec)
8047 {
8048   int per_index;
8049   unsigned int more_words = 0;
8050   struct absaddr addr;
8051   bfd_vma sym_name = (bfd_vma) -1;
8052
8053   if (remaining == 0)
8054     {
8055       /* Fetch the first word.
8056          Note - when decoding an object file the address extracted
8057          here will always be 0.  So we also pass in the sym_name
8058          parameter so that we can find the symbol associated with
8059          the personality routine.  */
8060       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8061                                      & word, & addr, & sym_name))
8062         return;
8063
8064       remaining = 4;
8065     }
8066
8067   if ((word & 0x80000000) == 0)
8068     {
8069       /* Expand prel31 for personality routine.  */
8070       bfd_vma fn;
8071       const char *procname;
8072
8073       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8074       printf (_("  Personality routine: "));
8075       if (fn == 0
8076           && addr.section == SHN_UNDEF && addr.offset == 0
8077           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8078         {
8079           procname = aux->strtab + sym_name;
8080           print_vma (fn, PREFIX_HEX);
8081           if (procname)
8082             {
8083               fputs (" <", stdout);
8084               fputs (procname, stdout);
8085               fputc ('>', stdout);
8086             }
8087         }
8088       else
8089         procname = arm_print_vma_and_name (aux, fn, addr);
8090       fputc ('\n', stdout);
8091
8092       /* The GCC personality routines use the standard compact
8093          encoding, starting with one byte giving the number of
8094          words.  */
8095       if (procname != NULL
8096           && (const_strneq (procname, "__gcc_personality_v0")
8097               || const_strneq (procname, "__gxx_personality_v0")
8098               || const_strneq (procname, "__gcj_personality_v0")
8099               || const_strneq (procname, "__gnu_objc_personality_v0")))
8100         {
8101           remaining = 0;
8102           more_words = 1;
8103           ADVANCE;
8104           if (!remaining)
8105             {
8106               printf (_("  [Truncated data]\n"));
8107               return;
8108             }
8109           more_words = word >> 24;
8110           word <<= 8;
8111           remaining--;
8112           per_index = -1;
8113         }
8114       else
8115         return;
8116     }
8117   else
8118     {
8119       /* ARM EHABI Section 6.3:
8120
8121          An exception-handling table entry for the compact model looks like:
8122
8123            31 30-28 27-24 23-0
8124            -- ----- ----- ----
8125             1   0   index Data for personalityRoutine[index]    */
8126
8127       if (elf_header.e_machine == EM_ARM
8128           && (word & 0x70000000))
8129         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8130
8131       per_index = (word >> 24) & 0x7f;
8132       printf (_("  Compact model index: %d\n"), per_index);
8133       if (per_index == 0)
8134         {
8135           more_words = 0;
8136           word <<= 8;
8137           remaining--;
8138         }
8139       else if (per_index < 3)
8140         {
8141           more_words = (word >> 16) & 0xff;
8142           word <<= 16;
8143           remaining -= 2;
8144         }
8145     }
8146
8147   switch (elf_header.e_machine)
8148     {
8149     case EM_ARM:
8150       if (per_index < 3)
8151         {
8152           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8153                                       data_offset, data_sec, data_arm_sec);
8154         }
8155       else
8156         {
8157           warn (_("Unknown ARM compact model index encountered\n"));
8158           printf (_("  [reserved]\n"));
8159         }
8160       break;
8161
8162     case EM_TI_C6000:
8163       if (per_index < 3)
8164         {
8165           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8166                                         data_offset, data_sec, data_arm_sec);
8167         }
8168       else if (per_index < 5)
8169         {
8170           if (((word >> 17) & 0x7f) == 0x7f)
8171             printf (_("  Restore stack from frame pointer\n"));
8172           else
8173             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8174           printf (_("  Registers restored: "));
8175           if (per_index == 4)
8176             printf (" (compact) ");
8177           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8178           putchar ('\n');
8179           printf (_("  Return register: %s\n"),
8180                   tic6x_unwind_regnames[word & 0xf]);
8181         }
8182       else
8183         printf (_("  [reserved (%d)]\n"), per_index);
8184       break;
8185
8186     default:
8187       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8188              elf_header.e_machine);
8189     }
8190
8191   /* Decode the descriptors.  Not implemented.  */
8192 }
8193
8194 static void
8195 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8196 {
8197   struct arm_section exidx_arm_sec, extab_arm_sec;
8198   unsigned int i, exidx_len;
8199   unsigned long j, nfuns;
8200
8201   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8202   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8203   exidx_len = exidx_sec->sh_size / 8;
8204
8205   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8206   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8207     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8208       aux->funtab[nfuns++] = aux->symtab[j];
8209   aux->nfuns = nfuns;
8210   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8211
8212   for (i = 0; i < exidx_len; i++)
8213     {
8214       unsigned int exidx_fn, exidx_entry;
8215       struct absaddr fn_addr, entry_addr;
8216       bfd_vma fn;
8217
8218       fputc ('\n', stdout);
8219
8220       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8221                                      8 * i, & exidx_fn, & fn_addr, NULL)
8222           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8223                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8224         {
8225           free (aux->funtab);
8226           arm_free_section (& exidx_arm_sec);
8227           arm_free_section (& extab_arm_sec);
8228           return;
8229         }
8230
8231       /* ARM EHABI, Section 5:
8232          An index table entry consists of 2 words.
8233          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8234       if (exidx_fn & 0x80000000)
8235         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8236
8237       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8238
8239       arm_print_vma_and_name (aux, fn, fn_addr);
8240       fputs (": ", stdout);
8241
8242       if (exidx_entry == 1)
8243         {
8244           print_vma (exidx_entry, PREFIX_HEX);
8245           fputs (" [cantunwind]\n", stdout);
8246         }
8247       else if (exidx_entry & 0x80000000)
8248         {
8249           print_vma (exidx_entry, PREFIX_HEX);
8250           fputc ('\n', stdout);
8251           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8252         }
8253       else
8254         {
8255           bfd_vma table, table_offset = 0;
8256           Elf_Internal_Shdr *table_sec;
8257
8258           fputs ("@", stdout);
8259           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8260           print_vma (table, PREFIX_HEX);
8261           printf ("\n");
8262
8263           /* Locate the matching .ARM.extab.  */
8264           if (entry_addr.section != SHN_UNDEF
8265               && entry_addr.section < elf_header.e_shnum)
8266             {
8267               table_sec = section_headers + entry_addr.section;
8268               table_offset = entry_addr.offset;
8269             }
8270           else
8271             {
8272               table_sec = find_section_by_address (table);
8273               if (table_sec != NULL)
8274                 table_offset = table - table_sec->sh_addr;
8275             }
8276           if (table_sec == NULL)
8277             {
8278               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8279                     (unsigned long) table);
8280               continue;
8281             }
8282           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8283                              &extab_arm_sec);
8284         }
8285     }
8286
8287   printf ("\n");
8288
8289   free (aux->funtab);
8290   arm_free_section (&exidx_arm_sec);
8291   arm_free_section (&extab_arm_sec);
8292 }
8293
8294 /* Used for both ARM and C6X unwinding tables.  */
8295
8296 static void
8297 arm_process_unwind (FILE *file)
8298 {
8299   struct arm_unw_aux_info aux;
8300   Elf_Internal_Shdr *unwsec = NULL;
8301   Elf_Internal_Shdr *strsec;
8302   Elf_Internal_Shdr *sec;
8303   unsigned long i;
8304   unsigned int sec_type;
8305
8306   switch (elf_header.e_machine)
8307     {
8308     case EM_ARM:
8309       sec_type = SHT_ARM_EXIDX;
8310       break;
8311
8312     case EM_TI_C6000:
8313       sec_type = SHT_C6000_UNWIND;
8314       break;
8315
8316     default:
8317       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8318              elf_header.e_machine);
8319       return;
8320     }
8321
8322   if (string_table == NULL)
8323     return;
8324
8325   memset (& aux, 0, sizeof (aux));
8326   aux.file = file;
8327
8328   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8329     {
8330       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8331         {
8332           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8333
8334           strsec = section_headers + sec->sh_link;
8335
8336           /* PR binutils/17531 file: 011-12666-0.004.  */
8337           if (aux.strtab != NULL)
8338             {
8339               error (_("Multiple string tables found in file.\n"));
8340               free (aux.strtab);
8341             }
8342           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8343                                  1, strsec->sh_size, _("string table"));
8344           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8345         }
8346       else if (sec->sh_type == sec_type)
8347         unwsec = sec;
8348     }
8349
8350   if (unwsec == NULL)
8351     printf (_("\nThere are no unwind sections in this file.\n"));
8352   else
8353     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8354       {
8355         if (sec->sh_type == sec_type)
8356           {
8357             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8358                     printable_section_name (sec),
8359                     (unsigned long) sec->sh_offset,
8360                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8361
8362             dump_arm_unwind (&aux, sec);
8363           }
8364       }
8365
8366   if (aux.symtab)
8367     free (aux.symtab);
8368   if (aux.strtab)
8369     free ((char *) aux.strtab);
8370 }
8371
8372 static void
8373 process_unwind (FILE * file)
8374 {
8375   struct unwind_handler
8376   {
8377     int machtype;
8378     void (* handler)(FILE *);
8379   } handlers[] =
8380   {
8381     { EM_ARM, arm_process_unwind },
8382     { EM_IA_64, ia64_process_unwind },
8383     { EM_PARISC, hppa_process_unwind },
8384     { EM_TI_C6000, arm_process_unwind },
8385     { 0, 0 }
8386   };
8387   int i;
8388
8389   if (!do_unwind)
8390     return;
8391
8392   for (i = 0; handlers[i].handler != NULL; i++)
8393     if (elf_header.e_machine == handlers[i].machtype)
8394       {
8395         handlers[i].handler (file);
8396         return;
8397       }
8398
8399   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8400           get_machine_name (elf_header.e_machine));
8401 }
8402
8403 static void
8404 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8405 {
8406   switch (entry->d_tag)
8407     {
8408     case DT_MIPS_FLAGS:
8409       if (entry->d_un.d_val == 0)
8410         printf (_("NONE"));
8411       else
8412         {
8413           static const char * opts[] =
8414           {
8415             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8416             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8417             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8418             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8419             "RLD_ORDER_SAFE"
8420           };
8421           unsigned int cnt;
8422           int first = 1;
8423
8424           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8425             if (entry->d_un.d_val & (1 << cnt))
8426               {
8427                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8428                 first = 0;
8429               }
8430         }
8431       break;
8432
8433     case DT_MIPS_IVERSION:
8434       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8435         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8436       else
8437         {
8438           char buf[40];
8439           sprintf_vma (buf, entry->d_un.d_ptr);
8440           /* Note: coded this way so that there is a single string for translation.  */
8441           printf (_("<corrupt: %s>"), buf);
8442         }
8443       break;
8444
8445     case DT_MIPS_TIME_STAMP:
8446       {
8447         char timebuf[20];
8448         struct tm * tmp;
8449         time_t atime = entry->d_un.d_val;
8450
8451         tmp = gmtime (&atime);
8452         /* PR 17531: file: 6accc532.  */
8453         if (tmp == NULL)
8454           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8455         else
8456           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8457                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8458                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8459         printf (_("Time Stamp: %s"), timebuf);
8460       }
8461       break;
8462
8463     case DT_MIPS_RLD_VERSION:
8464     case DT_MIPS_LOCAL_GOTNO:
8465     case DT_MIPS_CONFLICTNO:
8466     case DT_MIPS_LIBLISTNO:
8467     case DT_MIPS_SYMTABNO:
8468     case DT_MIPS_UNREFEXTNO:
8469     case DT_MIPS_HIPAGENO:
8470     case DT_MIPS_DELTA_CLASS_NO:
8471     case DT_MIPS_DELTA_INSTANCE_NO:
8472     case DT_MIPS_DELTA_RELOC_NO:
8473     case DT_MIPS_DELTA_SYM_NO:
8474     case DT_MIPS_DELTA_CLASSSYM_NO:
8475     case DT_MIPS_COMPACT_SIZE:
8476       print_vma (entry->d_un.d_ptr, DEC);
8477       break;
8478
8479     default:
8480       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8481     }
8482     putchar ('\n');
8483 }
8484
8485 static void
8486 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8487 {
8488   switch (entry->d_tag)
8489     {
8490     case DT_HP_DLD_FLAGS:
8491       {
8492         static struct
8493         {
8494           long int bit;
8495           const char * str;
8496         }
8497         flags[] =
8498         {
8499           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8500           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8501           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8502           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8503           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8504           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8505           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8506           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8507           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8508           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8509           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8510           { DT_HP_GST, "HP_GST" },
8511           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8512           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8513           { DT_HP_NODELETE, "HP_NODELETE" },
8514           { DT_HP_GROUP, "HP_GROUP" },
8515           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8516         };
8517         int first = 1;
8518         size_t cnt;
8519         bfd_vma val = entry->d_un.d_val;
8520
8521         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8522           if (val & flags[cnt].bit)
8523             {
8524               if (! first)
8525                 putchar (' ');
8526               fputs (flags[cnt].str, stdout);
8527               first = 0;
8528               val ^= flags[cnt].bit;
8529             }
8530
8531         if (val != 0 || first)
8532           {
8533             if (! first)
8534               putchar (' ');
8535             print_vma (val, HEX);
8536           }
8537       }
8538       break;
8539
8540     default:
8541       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8542       break;
8543     }
8544   putchar ('\n');
8545 }
8546
8547 #ifdef BFD64
8548
8549 /* VMS vs Unix time offset and factor.  */
8550
8551 #define VMS_EPOCH_OFFSET 35067168000000000LL
8552 #define VMS_GRANULARITY_FACTOR 10000000
8553
8554 /* Display a VMS time in a human readable format.  */
8555
8556 static void
8557 print_vms_time (bfd_int64_t vmstime)
8558 {
8559   struct tm *tm;
8560   time_t unxtime;
8561
8562   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8563   tm = gmtime (&unxtime);
8564   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8565           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8566           tm->tm_hour, tm->tm_min, tm->tm_sec);
8567 }
8568 #endif /* BFD64 */
8569
8570 static void
8571 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8572 {
8573   switch (entry->d_tag)
8574     {
8575     case DT_IA_64_PLT_RESERVE:
8576       /* First 3 slots reserved.  */
8577       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8578       printf (" -- ");
8579       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8580       break;
8581
8582     case DT_IA_64_VMS_LINKTIME:
8583 #ifdef BFD64
8584       print_vms_time (entry->d_un.d_val);
8585 #endif
8586       break;
8587
8588     case DT_IA_64_VMS_LNKFLAGS:
8589       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8590       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8591         printf (" CALL_DEBUG");
8592       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8593         printf (" NOP0BUFS");
8594       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8595         printf (" P0IMAGE");
8596       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8597         printf (" MKTHREADS");
8598       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8599         printf (" UPCALLS");
8600       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8601         printf (" IMGSTA");
8602       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8603         printf (" INITIALIZE");
8604       if (entry->d_un.d_val & VMS_LF_MAIN)
8605         printf (" MAIN");
8606       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8607         printf (" EXE_INIT");
8608       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8609         printf (" TBK_IN_IMG");
8610       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8611         printf (" DBG_IN_IMG");
8612       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8613         printf (" TBK_IN_DSF");
8614       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8615         printf (" DBG_IN_DSF");
8616       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8617         printf (" SIGNATURES");
8618       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8619         printf (" REL_SEG_OFF");
8620       break;
8621
8622     default:
8623       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8624       break;
8625     }
8626   putchar ('\n');
8627 }
8628
8629 static int
8630 get_32bit_dynamic_section (FILE * file)
8631 {
8632   Elf32_External_Dyn * edyn;
8633   Elf32_External_Dyn * ext;
8634   Elf_Internal_Dyn * entry;
8635
8636   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8637                                           dynamic_size, _("dynamic section"));
8638   if (!edyn)
8639     return 0;
8640
8641   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8642      might not have the luxury of section headers.  Look for the DT_NULL
8643      terminator to determine the number of entries.  */
8644   for (ext = edyn, dynamic_nent = 0;
8645        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8646        ext++)
8647     {
8648       dynamic_nent++;
8649       if (BYTE_GET (ext->d_tag) == DT_NULL)
8650         break;
8651     }
8652
8653   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8654                                                   sizeof (* entry));
8655   if (dynamic_section == NULL)
8656     {
8657       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8658              (unsigned long) dynamic_nent);
8659       free (edyn);
8660       return 0;
8661     }
8662
8663   for (ext = edyn, entry = dynamic_section;
8664        entry < dynamic_section + dynamic_nent;
8665        ext++, entry++)
8666     {
8667       entry->d_tag      = BYTE_GET (ext->d_tag);
8668       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8669     }
8670
8671   free (edyn);
8672
8673   return 1;
8674 }
8675
8676 static int
8677 get_64bit_dynamic_section (FILE * file)
8678 {
8679   Elf64_External_Dyn * edyn;
8680   Elf64_External_Dyn * ext;
8681   Elf_Internal_Dyn * entry;
8682
8683   /* Read in the data.  */
8684   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8685                                           dynamic_size, _("dynamic section"));
8686   if (!edyn)
8687     return 0;
8688
8689   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8690      might not have the luxury of section headers.  Look for the DT_NULL
8691      terminator to determine the number of entries.  */
8692   for (ext = edyn, dynamic_nent = 0;
8693        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8694        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8695        ext++)
8696     {
8697       dynamic_nent++;
8698       if (BYTE_GET (ext->d_tag) == DT_NULL)
8699         break;
8700     }
8701
8702   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8703                                                   sizeof (* entry));
8704   if (dynamic_section == NULL)
8705     {
8706       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8707              (unsigned long) dynamic_nent);
8708       free (edyn);
8709       return 0;
8710     }
8711
8712   /* Convert from external to internal formats.  */
8713   for (ext = edyn, entry = dynamic_section;
8714        entry < dynamic_section + dynamic_nent;
8715        ext++, entry++)
8716     {
8717       entry->d_tag      = BYTE_GET (ext->d_tag);
8718       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8719     }
8720
8721   free (edyn);
8722
8723   return 1;
8724 }
8725
8726 static void
8727 print_dynamic_flags (bfd_vma flags)
8728 {
8729   int first = 1;
8730
8731   while (flags)
8732     {
8733       bfd_vma flag;
8734
8735       flag = flags & - flags;
8736       flags &= ~ flag;
8737
8738       if (first)
8739         first = 0;
8740       else
8741         putc (' ', stdout);
8742
8743       switch (flag)
8744         {
8745         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8746         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8747         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8748         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8749         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8750         default:                fputs (_("unknown"), stdout); break;
8751         }
8752     }
8753   puts ("");
8754 }
8755
8756 /* Parse and display the contents of the dynamic section.  */
8757
8758 static int
8759 process_dynamic_section (FILE * file)
8760 {
8761   Elf_Internal_Dyn * entry;
8762
8763   if (dynamic_size == 0)
8764     {
8765       if (do_dynamic)
8766         printf (_("\nThere is no dynamic section in this file.\n"));
8767
8768       return 1;
8769     }
8770
8771   if (is_32bit_elf)
8772     {
8773       if (! get_32bit_dynamic_section (file))
8774         return 0;
8775     }
8776   else if (! get_64bit_dynamic_section (file))
8777     return 0;
8778
8779   /* Find the appropriate symbol table.  */
8780   if (dynamic_symbols == NULL)
8781     {
8782       for (entry = dynamic_section;
8783            entry < dynamic_section + dynamic_nent;
8784            ++entry)
8785         {
8786           Elf_Internal_Shdr section;
8787
8788           if (entry->d_tag != DT_SYMTAB)
8789             continue;
8790
8791           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8792
8793           /* Since we do not know how big the symbol table is,
8794              we default to reading in the entire file (!) and
8795              processing that.  This is overkill, I know, but it
8796              should work.  */
8797           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8798
8799           if (archive_file_offset != 0)
8800             section.sh_size = archive_file_size - section.sh_offset;
8801           else
8802             {
8803               if (fseek (file, 0, SEEK_END))
8804                 error (_("Unable to seek to end of file!\n"));
8805
8806               section.sh_size = ftell (file) - section.sh_offset;
8807             }
8808
8809           if (is_32bit_elf)
8810             section.sh_entsize = sizeof (Elf32_External_Sym);
8811           else
8812             section.sh_entsize = sizeof (Elf64_External_Sym);
8813           section.sh_name = string_table_length;
8814
8815           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8816           if (num_dynamic_syms < 1)
8817             {
8818               error (_("Unable to determine the number of symbols to load\n"));
8819               continue;
8820             }
8821         }
8822     }
8823
8824   /* Similarly find a string table.  */
8825   if (dynamic_strings == NULL)
8826     {
8827       for (entry = dynamic_section;
8828            entry < dynamic_section + dynamic_nent;
8829            ++entry)
8830         {
8831           unsigned long offset;
8832           long str_tab_len;
8833
8834           if (entry->d_tag != DT_STRTAB)
8835             continue;
8836
8837           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8838
8839           /* Since we do not know how big the string table is,
8840              we default to reading in the entire file (!) and
8841              processing that.  This is overkill, I know, but it
8842              should work.  */
8843
8844           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8845
8846           if (archive_file_offset != 0)
8847             str_tab_len = archive_file_size - offset;
8848           else
8849             {
8850               if (fseek (file, 0, SEEK_END))
8851                 error (_("Unable to seek to end of file\n"));
8852               str_tab_len = ftell (file) - offset;
8853             }
8854
8855           if (str_tab_len < 1)
8856             {
8857               error
8858                 (_("Unable to determine the length of the dynamic string table\n"));
8859               continue;
8860             }
8861
8862           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8863                                                str_tab_len,
8864                                                _("dynamic string table"));
8865           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8866           break;
8867         }
8868     }
8869
8870   /* And find the syminfo section if available.  */
8871   if (dynamic_syminfo == NULL)
8872     {
8873       unsigned long syminsz = 0;
8874
8875       for (entry = dynamic_section;
8876            entry < dynamic_section + dynamic_nent;
8877            ++entry)
8878         {
8879           if (entry->d_tag == DT_SYMINENT)
8880             {
8881               /* Note: these braces are necessary to avoid a syntax
8882                  error from the SunOS4 C compiler.  */
8883               /* PR binutils/17531: A corrupt file can trigger this test.
8884                  So do not use an assert, instead generate an error message.  */
8885               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8886                 error (_("Bad value (%d) for SYMINENT entry\n"),
8887                        (int) entry->d_un.d_val);
8888             }
8889           else if (entry->d_tag == DT_SYMINSZ)
8890             syminsz = entry->d_un.d_val;
8891           else if (entry->d_tag == DT_SYMINFO)
8892             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8893                                                       syminsz);
8894         }
8895
8896       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8897         {
8898           Elf_External_Syminfo * extsyminfo;
8899           Elf_External_Syminfo * extsym;
8900           Elf_Internal_Syminfo * syminfo;
8901
8902           /* There is a syminfo section.  Read the data.  */
8903           extsyminfo = (Elf_External_Syminfo *)
8904               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8905                         _("symbol information"));
8906           if (!extsyminfo)
8907             return 0;
8908
8909           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8910           if (dynamic_syminfo == NULL)
8911             {
8912               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8913                      (unsigned long) syminsz);
8914               return 0;
8915             }
8916
8917           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8918           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8919                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8920                ++syminfo, ++extsym)
8921             {
8922               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8923               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8924             }
8925
8926           free (extsyminfo);
8927         }
8928     }
8929
8930   if (do_dynamic && dynamic_addr)
8931     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8932             dynamic_addr, (unsigned long) dynamic_nent);
8933   if (do_dynamic)
8934     printf (_("  Tag        Type                         Name/Value\n"));
8935
8936   for (entry = dynamic_section;
8937        entry < dynamic_section + dynamic_nent;
8938        entry++)
8939     {
8940       if (do_dynamic)
8941         {
8942           const char * dtype;
8943
8944           putchar (' ');
8945           print_vma (entry->d_tag, FULL_HEX);
8946           dtype = get_dynamic_type (entry->d_tag);
8947           printf (" (%s)%*s", dtype,
8948                   ((is_32bit_elf ? 27 : 19)
8949                    - (int) strlen (dtype)),
8950                   " ");
8951         }
8952
8953       switch (entry->d_tag)
8954         {
8955         case DT_FLAGS:
8956           if (do_dynamic)
8957             print_dynamic_flags (entry->d_un.d_val);
8958           break;
8959
8960         case DT_AUXILIARY:
8961         case DT_FILTER:
8962         case DT_CONFIG:
8963         case DT_DEPAUDIT:
8964         case DT_AUDIT:
8965           if (do_dynamic)
8966             {
8967               switch (entry->d_tag)
8968                 {
8969                 case DT_AUXILIARY:
8970                   printf (_("Auxiliary library"));
8971                   break;
8972
8973                 case DT_FILTER:
8974                   printf (_("Filter library"));
8975                   break;
8976
8977                 case DT_CONFIG:
8978                   printf (_("Configuration file"));
8979                   break;
8980
8981                 case DT_DEPAUDIT:
8982                   printf (_("Dependency audit library"));
8983                   break;
8984
8985                 case DT_AUDIT:
8986                   printf (_("Audit library"));
8987                   break;
8988                 }
8989
8990               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8991                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8992               else
8993                 {
8994                   printf (": ");
8995                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8996                   putchar ('\n');
8997                 }
8998             }
8999           break;
9000
9001         case DT_FEATURE:
9002           if (do_dynamic)
9003             {
9004               printf (_("Flags:"));
9005
9006               if (entry->d_un.d_val == 0)
9007                 printf (_(" None\n"));
9008               else
9009                 {
9010                   unsigned long int val = entry->d_un.d_val;
9011
9012                   if (val & DTF_1_PARINIT)
9013                     {
9014                       printf (" PARINIT");
9015                       val ^= DTF_1_PARINIT;
9016                     }
9017                   if (val & DTF_1_CONFEXP)
9018                     {
9019                       printf (" CONFEXP");
9020                       val ^= DTF_1_CONFEXP;
9021                     }
9022                   if (val != 0)
9023                     printf (" %lx", val);
9024                   puts ("");
9025                 }
9026             }
9027           break;
9028
9029         case DT_POSFLAG_1:
9030           if (do_dynamic)
9031             {
9032               printf (_("Flags:"));
9033
9034               if (entry->d_un.d_val == 0)
9035                 printf (_(" None\n"));
9036               else
9037                 {
9038                   unsigned long int val = entry->d_un.d_val;
9039
9040                   if (val & DF_P1_LAZYLOAD)
9041                     {
9042                       printf (" LAZYLOAD");
9043                       val ^= DF_P1_LAZYLOAD;
9044                     }
9045                   if (val & DF_P1_GROUPPERM)
9046                     {
9047                       printf (" GROUPPERM");
9048                       val ^= DF_P1_GROUPPERM;
9049                     }
9050                   if (val != 0)
9051                     printf (" %lx", val);
9052                   puts ("");
9053                 }
9054             }
9055           break;
9056
9057         case DT_FLAGS_1:
9058           if (do_dynamic)
9059             {
9060               printf (_("Flags:"));
9061               if (entry->d_un.d_val == 0)
9062                 printf (_(" None\n"));
9063               else
9064                 {
9065                   unsigned long int val = entry->d_un.d_val;
9066
9067                   if (val & DF_1_NOW)
9068                     {
9069                       printf (" NOW");
9070                       val ^= DF_1_NOW;
9071                     }
9072                   if (val & DF_1_GLOBAL)
9073                     {
9074                       printf (" GLOBAL");
9075                       val ^= DF_1_GLOBAL;
9076                     }
9077                   if (val & DF_1_GROUP)
9078                     {
9079                       printf (" GROUP");
9080                       val ^= DF_1_GROUP;
9081                     }
9082                   if (val & DF_1_NODELETE)
9083                     {
9084                       printf (" NODELETE");
9085                       val ^= DF_1_NODELETE;
9086                     }
9087                   if (val & DF_1_LOADFLTR)
9088                     {
9089                       printf (" LOADFLTR");
9090                       val ^= DF_1_LOADFLTR;
9091                     }
9092                   if (val & DF_1_INITFIRST)
9093                     {
9094                       printf (" INITFIRST");
9095                       val ^= DF_1_INITFIRST;
9096                     }
9097                   if (val & DF_1_NOOPEN)
9098                     {
9099                       printf (" NOOPEN");
9100                       val ^= DF_1_NOOPEN;
9101                     }
9102                   if (val & DF_1_ORIGIN)
9103                     {
9104                       printf (" ORIGIN");
9105                       val ^= DF_1_ORIGIN;
9106                     }
9107                   if (val & DF_1_DIRECT)
9108                     {
9109                       printf (" DIRECT");
9110                       val ^= DF_1_DIRECT;
9111                     }
9112                   if (val & DF_1_TRANS)
9113                     {
9114                       printf (" TRANS");
9115                       val ^= DF_1_TRANS;
9116                     }
9117                   if (val & DF_1_INTERPOSE)
9118                     {
9119                       printf (" INTERPOSE");
9120                       val ^= DF_1_INTERPOSE;
9121                     }
9122                   if (val & DF_1_NODEFLIB)
9123                     {
9124                       printf (" NODEFLIB");
9125                       val ^= DF_1_NODEFLIB;
9126                     }
9127                   if (val & DF_1_NODUMP)
9128                     {
9129                       printf (" NODUMP");
9130                       val ^= DF_1_NODUMP;
9131                     }
9132                   if (val & DF_1_CONFALT)
9133                     {
9134                       printf (" CONFALT");
9135                       val ^= DF_1_CONFALT;
9136                     }
9137                   if (val & DF_1_ENDFILTEE)
9138                     {
9139                       printf (" ENDFILTEE");
9140                       val ^= DF_1_ENDFILTEE;
9141                     }
9142                   if (val & DF_1_DISPRELDNE)
9143                     {
9144                       printf (" DISPRELDNE");
9145                       val ^= DF_1_DISPRELDNE;
9146                     }
9147                   if (val & DF_1_DISPRELPND)
9148                     {
9149                       printf (" DISPRELPND");
9150                       val ^= DF_1_DISPRELPND;
9151                     }
9152                   if (val & DF_1_NODIRECT)
9153                     {
9154                       printf (" NODIRECT");
9155                       val ^= DF_1_NODIRECT;
9156                     }
9157                   if (val & DF_1_IGNMULDEF)
9158                     {
9159                       printf (" IGNMULDEF");
9160                       val ^= DF_1_IGNMULDEF;
9161                     }
9162                   if (val & DF_1_NOKSYMS)
9163                     {
9164                       printf (" NOKSYMS");
9165                       val ^= DF_1_NOKSYMS;
9166                     }
9167                   if (val & DF_1_NOHDR)
9168                     {
9169                       printf (" NOHDR");
9170                       val ^= DF_1_NOHDR;
9171                     }
9172                   if (val & DF_1_EDITED)
9173                     {
9174                       printf (" EDITED");
9175                       val ^= DF_1_EDITED;
9176                     }
9177                   if (val & DF_1_NORELOC)
9178                     {
9179                       printf (" NORELOC");
9180                       val ^= DF_1_NORELOC;
9181                     }
9182                   if (val & DF_1_SYMINTPOSE)
9183                     {
9184                       printf (" SYMINTPOSE");
9185                       val ^= DF_1_SYMINTPOSE;
9186                     }
9187                   if (val & DF_1_GLOBAUDIT)
9188                     {
9189                       printf (" GLOBAUDIT");
9190                       val ^= DF_1_GLOBAUDIT;
9191                     }
9192                   if (val & DF_1_SINGLETON)
9193                     {
9194                       printf (" SINGLETON");
9195                       val ^= DF_1_SINGLETON;
9196                     }
9197                   if (val != 0)
9198                     printf (" %lx", val);
9199                   puts ("");
9200                 }
9201             }
9202           break;
9203
9204         case DT_PLTREL:
9205           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9206           if (do_dynamic)
9207             puts (get_dynamic_type (entry->d_un.d_val));
9208           break;
9209
9210         case DT_NULL    :
9211         case DT_NEEDED  :
9212         case DT_PLTGOT  :
9213         case DT_HASH    :
9214         case DT_STRTAB  :
9215         case DT_SYMTAB  :
9216         case DT_RELA    :
9217         case DT_INIT    :
9218         case DT_FINI    :
9219         case DT_SONAME  :
9220         case DT_RPATH   :
9221         case DT_SYMBOLIC:
9222         case DT_REL     :
9223         case DT_DEBUG   :
9224         case DT_TEXTREL :
9225         case DT_JMPREL  :
9226         case DT_RUNPATH :
9227           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9228
9229           if (do_dynamic)
9230             {
9231               char * name;
9232
9233               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9234                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9235               else
9236                 name = NULL;
9237
9238               if (name)
9239                 {
9240                   switch (entry->d_tag)
9241                     {
9242                     case DT_NEEDED:
9243                       printf (_("Shared library: [%s]"), name);
9244
9245                       if (streq (name, program_interpreter))
9246                         printf (_(" program interpreter"));
9247                       break;
9248
9249                     case DT_SONAME:
9250                       printf (_("Library soname: [%s]"), name);
9251                       break;
9252
9253                     case DT_RPATH:
9254                       printf (_("Library rpath: [%s]"), name);
9255                       break;
9256
9257                     case DT_RUNPATH:
9258                       printf (_("Library runpath: [%s]"), name);
9259                       break;
9260
9261                     default:
9262                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9263                       break;
9264                     }
9265                 }
9266               else
9267                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9268
9269               putchar ('\n');
9270             }
9271           break;
9272
9273         case DT_PLTRELSZ:
9274         case DT_RELASZ  :
9275         case DT_STRSZ   :
9276         case DT_RELSZ   :
9277         case DT_RELAENT :
9278         case DT_SYMENT  :
9279         case DT_RELENT  :
9280           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9281         case DT_PLTPADSZ:
9282         case DT_MOVEENT :
9283         case DT_MOVESZ  :
9284         case DT_INIT_ARRAYSZ:
9285         case DT_FINI_ARRAYSZ:
9286         case DT_GNU_CONFLICTSZ:
9287         case DT_GNU_LIBLISTSZ:
9288           if (do_dynamic)
9289             {
9290               print_vma (entry->d_un.d_val, UNSIGNED);
9291               printf (_(" (bytes)\n"));
9292             }
9293           break;
9294
9295         case DT_VERDEFNUM:
9296         case DT_VERNEEDNUM:
9297         case DT_RELACOUNT:
9298         case DT_RELCOUNT:
9299           if (do_dynamic)
9300             {
9301               print_vma (entry->d_un.d_val, UNSIGNED);
9302               putchar ('\n');
9303             }
9304           break;
9305
9306         case DT_SYMINSZ:
9307         case DT_SYMINENT:
9308         case DT_SYMINFO:
9309         case DT_USED:
9310         case DT_INIT_ARRAY:
9311         case DT_FINI_ARRAY:
9312           if (do_dynamic)
9313             {
9314               if (entry->d_tag == DT_USED
9315                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9316                 {
9317                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9318
9319                   if (*name)
9320                     {
9321                       printf (_("Not needed object: [%s]\n"), name);
9322                       break;
9323                     }
9324                 }
9325
9326               print_vma (entry->d_un.d_val, PREFIX_HEX);
9327               putchar ('\n');
9328             }
9329           break;
9330
9331         case DT_BIND_NOW:
9332           /* The value of this entry is ignored.  */
9333           if (do_dynamic)
9334             putchar ('\n');
9335           break;
9336
9337         case DT_GNU_PRELINKED:
9338           if (do_dynamic)
9339             {
9340               struct tm * tmp;
9341               time_t atime = entry->d_un.d_val;
9342
9343               tmp = gmtime (&atime);
9344               /* PR 17533 file: 041-1244816-0.004.  */
9345               if (tmp == NULL)
9346                 printf (_("<corrupt time val: %lx"),
9347                         (unsigned long) atime);
9348               else
9349                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9350                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9351                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9352
9353             }
9354           break;
9355
9356         case DT_GNU_HASH:
9357           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9358           if (do_dynamic)
9359             {
9360               print_vma (entry->d_un.d_val, PREFIX_HEX);
9361               putchar ('\n');
9362             }
9363           break;
9364
9365         default:
9366           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9367             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9368               entry->d_un.d_val;
9369
9370           if (do_dynamic)
9371             {
9372               switch (elf_header.e_machine)
9373                 {
9374                 case EM_MIPS:
9375                 case EM_MIPS_RS3_LE:
9376                   dynamic_section_mips_val (entry);
9377                   break;
9378                 case EM_PARISC:
9379                   dynamic_section_parisc_val (entry);
9380                   break;
9381                 case EM_IA_64:
9382                   dynamic_section_ia64_val (entry);
9383                   break;
9384                 default:
9385                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9386                   putchar ('\n');
9387                 }
9388             }
9389           break;
9390         }
9391     }
9392
9393   return 1;
9394 }
9395
9396 static char *
9397 get_ver_flags (unsigned int flags)
9398 {
9399   static char buff[32];
9400
9401   buff[0] = 0;
9402
9403   if (flags == 0)
9404     return _("none");
9405
9406   if (flags & VER_FLG_BASE)
9407     strcat (buff, "BASE ");
9408
9409   if (flags & VER_FLG_WEAK)
9410     {
9411       if (flags & VER_FLG_BASE)
9412         strcat (buff, "| ");
9413
9414       strcat (buff, "WEAK ");
9415     }
9416
9417   if (flags & VER_FLG_INFO)
9418     {
9419       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9420         strcat (buff, "| ");
9421
9422       strcat (buff, "INFO ");
9423     }
9424
9425   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9426     strcat (buff, _("| <unknown>"));
9427
9428   return buff;
9429 }
9430
9431 /* Display the contents of the version sections.  */
9432
9433 static int
9434 process_version_sections (FILE * file)
9435 {
9436   Elf_Internal_Shdr * section;
9437   unsigned i;
9438   int found = 0;
9439
9440   if (! do_version)
9441     return 1;
9442
9443   for (i = 0, section = section_headers;
9444        i < elf_header.e_shnum;
9445        i++, section++)
9446     {
9447       switch (section->sh_type)
9448         {
9449         case SHT_GNU_verdef:
9450           {
9451             Elf_External_Verdef * edefs;
9452             unsigned int idx;
9453             unsigned int cnt;
9454             char * endbuf;
9455
9456             found = 1;
9457
9458             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9459                     printable_section_name (section),
9460                     section->sh_info);
9461
9462             printf (_("  Addr: 0x"));
9463             printf_vma (section->sh_addr);
9464             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9465                     (unsigned long) section->sh_offset, section->sh_link,
9466                     printable_section_name_from_index (section->sh_link));
9467
9468             edefs = (Elf_External_Verdef *)
9469                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9470                           _("version definition section"));
9471             if (!edefs)
9472               break;
9473             endbuf = (char *) edefs + section->sh_size;
9474
9475             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9476               {
9477                 char * vstart;
9478                 Elf_External_Verdef * edef;
9479                 Elf_Internal_Verdef ent;
9480                 Elf_External_Verdaux * eaux;
9481                 Elf_Internal_Verdaux aux;
9482                 int j;
9483                 int isum;
9484
9485                 /* Check for very large indicies.  */
9486                 if (idx > (size_t) (endbuf - (char *) edefs))
9487                   break;
9488
9489                 vstart = ((char *) edefs) + idx;
9490                 if (vstart + sizeof (*edef) > endbuf)
9491                   break;
9492
9493                 edef = (Elf_External_Verdef *) vstart;
9494
9495                 ent.vd_version = BYTE_GET (edef->vd_version);
9496                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9497                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9498                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9499                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9500                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9501                 ent.vd_next    = BYTE_GET (edef->vd_next);
9502
9503                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9504                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9505
9506                 printf (_("  Index: %d  Cnt: %d  "),
9507                         ent.vd_ndx, ent.vd_cnt);
9508
9509                 /* Check for overflow.  */
9510                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9511                   break;
9512
9513                 vstart += ent.vd_aux;
9514
9515                 eaux = (Elf_External_Verdaux *) vstart;
9516
9517                 aux.vda_name = BYTE_GET (eaux->vda_name);
9518                 aux.vda_next = BYTE_GET (eaux->vda_next);
9519
9520                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9521                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9522                 else
9523                   printf (_("Name index: %ld\n"), aux.vda_name);
9524
9525                 isum = idx + ent.vd_aux;
9526
9527                 for (j = 1; j < ent.vd_cnt; j++)
9528                   {
9529                     /* Check for overflow.  */
9530                     if (aux.vda_next > (size_t) (endbuf - vstart))
9531                       break;
9532
9533                     isum   += aux.vda_next;
9534                     vstart += aux.vda_next;
9535
9536                     eaux = (Elf_External_Verdaux *) vstart;
9537                     if (vstart + sizeof (*eaux) > endbuf)
9538                       break;
9539
9540                     aux.vda_name = BYTE_GET (eaux->vda_name);
9541                     aux.vda_next = BYTE_GET (eaux->vda_next);
9542
9543                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9544                       printf (_("  %#06x: Parent %d: %s\n"),
9545                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9546                     else
9547                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9548                               isum, j, aux.vda_name);
9549                   }
9550
9551                 if (j < ent.vd_cnt)
9552                   printf (_("  Version def aux past end of section\n"));
9553
9554                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9555                 if (idx + ent.vd_next <= idx)
9556                   break;
9557
9558                 idx += ent.vd_next;
9559               }
9560
9561             if (cnt < section->sh_info)
9562               printf (_("  Version definition past end of section\n"));
9563
9564             free (edefs);
9565           }
9566           break;
9567
9568         case SHT_GNU_verneed:
9569           {
9570             Elf_External_Verneed * eneed;
9571             unsigned int idx;
9572             unsigned int cnt;
9573             char * endbuf;
9574
9575             found = 1;
9576
9577             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9578                     printable_section_name (section), section->sh_info);
9579
9580             printf (_(" Addr: 0x"));
9581             printf_vma (section->sh_addr);
9582             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9583                     (unsigned long) section->sh_offset, section->sh_link,
9584                     printable_section_name_from_index (section->sh_link));
9585
9586             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9587                                                        section->sh_offset, 1,
9588                                                        section->sh_size,
9589                                                        _("Version Needs section"));
9590             if (!eneed)
9591               break;
9592             endbuf = (char *) eneed + section->sh_size;
9593
9594             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9595               {
9596                 Elf_External_Verneed * entry;
9597                 Elf_Internal_Verneed ent;
9598                 int j;
9599                 int isum;
9600                 char * vstart;
9601
9602                 if (idx > (size_t) (endbuf - (char *) eneed))
9603                   break;
9604
9605                 vstart = ((char *) eneed) + idx;
9606                 if (vstart + sizeof (*entry) > endbuf)
9607                   break;
9608
9609                 entry = (Elf_External_Verneed *) vstart;
9610
9611                 ent.vn_version = BYTE_GET (entry->vn_version);
9612                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9613                 ent.vn_file    = BYTE_GET (entry->vn_file);
9614                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9615                 ent.vn_next    = BYTE_GET (entry->vn_next);
9616
9617                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9618
9619                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9620                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9621                 else
9622                   printf (_("  File: %lx"), ent.vn_file);
9623
9624                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9625
9626                 /* Check for overflow.  */
9627                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9628                   break;
9629                 vstart += ent.vn_aux;
9630
9631                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9632                   {
9633                     Elf_External_Vernaux * eaux;
9634                     Elf_Internal_Vernaux aux;
9635
9636                     if (vstart + sizeof (*eaux) > endbuf)
9637                       break;
9638                     eaux = (Elf_External_Vernaux *) vstart;
9639
9640                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9641                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9642                     aux.vna_other = BYTE_GET (eaux->vna_other);
9643                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9644                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9645
9646                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9647                       printf (_("  %#06x:   Name: %s"),
9648                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9649                     else
9650                       printf (_("  %#06x:   Name index: %lx"),
9651                               isum, aux.vna_name);
9652
9653                     printf (_("  Flags: %s  Version: %d\n"),
9654                             get_ver_flags (aux.vna_flags), aux.vna_other);
9655
9656                     /* Check for overflow.  */
9657                     if (aux.vna_next > (size_t) (endbuf - vstart)
9658                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9659                       {
9660                         warn (_("Invalid vna_next field of %lx\n"),
9661                               aux.vna_next);
9662                         j = ent.vn_cnt;
9663                         break;
9664                       }
9665                     isum   += aux.vna_next;
9666                     vstart += aux.vna_next;
9667                   }
9668
9669                 if (j < ent.vn_cnt)
9670                   warn (_("Missing Version Needs auxillary information\n"));
9671
9672                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9673                   {
9674                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9675                     cnt = section->sh_info;
9676                     break;
9677                   }
9678                 idx += ent.vn_next;
9679               }
9680
9681             if (cnt < section->sh_info)
9682               warn (_("Missing Version Needs information\n"));
9683
9684             free (eneed);
9685           }
9686           break;
9687
9688         case SHT_GNU_versym:
9689           {
9690             Elf_Internal_Shdr * link_section;
9691             size_t total;
9692             unsigned int cnt;
9693             unsigned char * edata;
9694             unsigned short * data;
9695             char * strtab;
9696             Elf_Internal_Sym * symbols;
9697             Elf_Internal_Shdr * string_sec;
9698             unsigned long num_syms;
9699             long off;
9700
9701             if (section->sh_link >= elf_header.e_shnum)
9702               break;
9703
9704             link_section = section_headers + section->sh_link;
9705             total = section->sh_size / sizeof (Elf_External_Versym);
9706
9707             if (link_section->sh_link >= elf_header.e_shnum)
9708               break;
9709
9710             found = 1;
9711
9712             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9713             if (symbols == NULL)
9714               break;
9715
9716             string_sec = section_headers + link_section->sh_link;
9717
9718             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9719                                         string_sec->sh_size,
9720                                         _("version string table"));
9721             if (!strtab)
9722               {
9723                 free (symbols);
9724                 break;
9725               }
9726
9727             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9728                     printable_section_name (section), (unsigned long) total);
9729
9730             printf (_(" Addr: "));
9731             printf_vma (section->sh_addr);
9732             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9733                     (unsigned long) section->sh_offset, section->sh_link,
9734                     printable_section_name (link_section));
9735
9736             off = offset_from_vma (file,
9737                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9738                                    total * sizeof (short));
9739             edata = (unsigned char *) get_data (NULL, file, off, total,
9740                                                 sizeof (short),
9741                                                 _("version symbol data"));
9742             if (!edata)
9743               {
9744                 free (strtab);
9745                 free (symbols);
9746                 break;
9747               }
9748
9749             data = (short unsigned int *) cmalloc (total, sizeof (short));
9750
9751             for (cnt = total; cnt --;)
9752               data[cnt] = byte_get (edata + cnt * sizeof (short),
9753                                     sizeof (short));
9754
9755             free (edata);
9756
9757             for (cnt = 0; cnt < total; cnt += 4)
9758               {
9759                 int j, nn;
9760                 int check_def, check_need;
9761                 char * name;
9762
9763                 printf ("  %03x:", cnt);
9764
9765                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9766                   switch (data[cnt + j])
9767                     {
9768                     case 0:
9769                       fputs (_("   0 (*local*)    "), stdout);
9770                       break;
9771
9772                     case 1:
9773                       fputs (_("   1 (*global*)   "), stdout);
9774                       break;
9775
9776                     default:
9777                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9778                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9779
9780                       /* If this index value is greater than the size of the symbols
9781                          array, break to avoid an out-of-bounds read.  */
9782                       if ((unsigned long)(cnt + j) >= num_syms)
9783                         {
9784                           warn (_("invalid index into symbol array\n"));
9785                           break;
9786                         }
9787
9788                       check_def = 1;
9789                       check_need = 1;
9790                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9791                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9792                              != SHT_NOBITS)
9793                         {
9794                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9795                             check_def = 0;
9796                           else
9797                             check_need = 0;
9798                         }
9799
9800                       if (check_need
9801                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9802                         {
9803                           Elf_Internal_Verneed ivn;
9804                           unsigned long offset;
9805
9806                           offset = offset_from_vma
9807                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9808                              sizeof (Elf_External_Verneed));
9809
9810                           do
9811                             {
9812                               Elf_Internal_Vernaux ivna;
9813                               Elf_External_Verneed evn;
9814                               Elf_External_Vernaux evna;
9815                               unsigned long a_off;
9816
9817                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9818                                             _("version need")) == NULL)
9819                                 break;
9820
9821                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9822                               ivn.vn_next = BYTE_GET (evn.vn_next);
9823
9824                               a_off = offset + ivn.vn_aux;
9825
9826                               do
9827                                 {
9828                                   if (get_data (&evna, file, a_off, sizeof (evna),
9829                                                 1, _("version need aux (2)")) == NULL)
9830                                     {
9831                                       ivna.vna_next  = 0;
9832                                       ivna.vna_other = 0;
9833                                     }
9834                                   else
9835                                     {
9836                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9837                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9838                                     }
9839
9840                                   a_off += ivna.vna_next;
9841                                 }
9842                               while (ivna.vna_other != data[cnt + j]
9843                                      && ivna.vna_next != 0);
9844
9845                               if (ivna.vna_other == data[cnt + j])
9846                                 {
9847                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9848
9849                                   if (ivna.vna_name >= string_sec->sh_size)
9850                                     name = _("*invalid*");
9851                                   else
9852                                     name = strtab + ivna.vna_name;
9853                                   nn += printf ("(%s%-*s",
9854                                                 name,
9855                                                 12 - (int) strlen (name),
9856                                                 ")");
9857                                   check_def = 0;
9858                                   break;
9859                                 }
9860
9861                               offset += ivn.vn_next;
9862                             }
9863                           while (ivn.vn_next);
9864                         }
9865
9866                       if (check_def && data[cnt + j] != 0x8001
9867                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9868                         {
9869                           Elf_Internal_Verdef ivd;
9870                           Elf_External_Verdef evd;
9871                           unsigned long offset;
9872
9873                           offset = offset_from_vma
9874                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9875                              sizeof evd);
9876
9877                           do
9878                             {
9879                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9880                                             _("version def")) == NULL)
9881                                 {
9882                                   ivd.vd_next = 0;
9883                                   /* PR 17531: file: 046-1082287-0.004.  */
9884                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9885                                   break;
9886                                 }
9887                               else
9888                                 {
9889                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9890                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9891                                 }
9892
9893                               offset += ivd.vd_next;
9894                             }
9895                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9896                                  && ivd.vd_next != 0);
9897
9898                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9899                             {
9900                               Elf_External_Verdaux evda;
9901                               Elf_Internal_Verdaux ivda;
9902
9903                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9904
9905                               if (get_data (&evda, file,
9906                                             offset - ivd.vd_next + ivd.vd_aux,
9907                                             sizeof (evda), 1,
9908                                             _("version def aux")) == NULL)
9909                                 break;
9910
9911                               ivda.vda_name = BYTE_GET (evda.vda_name);
9912
9913                               if (ivda.vda_name >= string_sec->sh_size)
9914                                 name = _("*invalid*");
9915                               else
9916                                 name = strtab + ivda.vda_name;
9917                               nn += printf ("(%s%-*s",
9918                                             name,
9919                                             12 - (int) strlen (name),
9920                                             ")");
9921                             }
9922                         }
9923
9924                       if (nn < 18)
9925                         printf ("%*c", 18 - nn, ' ');
9926                     }
9927
9928                 putchar ('\n');
9929               }
9930
9931             free (data);
9932             free (strtab);
9933             free (symbols);
9934           }
9935           break;
9936
9937         default:
9938           break;
9939         }
9940     }
9941
9942   if (! found)
9943     printf (_("\nNo version information found in this file.\n"));
9944
9945   return 1;
9946 }
9947
9948 static const char *
9949 get_symbol_binding (unsigned int binding)
9950 {
9951   static char buff[32];
9952
9953   switch (binding)
9954     {
9955     case STB_LOCAL:     return "LOCAL";
9956     case STB_GLOBAL:    return "GLOBAL";
9957     case STB_WEAK:      return "WEAK";
9958     default:
9959       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9960         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9961                   binding);
9962       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9963         {
9964           if (binding == STB_GNU_UNIQUE
9965               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9966                   /* GNU is still using the default value 0.  */
9967                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9968             return "UNIQUE";
9969           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9970         }
9971       else
9972         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9973       return buff;
9974     }
9975 }
9976
9977 static const char *
9978 get_symbol_type (unsigned int type)
9979 {
9980   static char buff[32];
9981
9982   switch (type)
9983     {
9984     case STT_NOTYPE:    return "NOTYPE";
9985     case STT_OBJECT:    return "OBJECT";
9986     case STT_FUNC:      return "FUNC";
9987     case STT_SECTION:   return "SECTION";
9988     case STT_FILE:      return "FILE";
9989     case STT_COMMON:    return "COMMON";
9990     case STT_TLS:       return "TLS";
9991     case STT_RELC:      return "RELC";
9992     case STT_SRELC:     return "SRELC";
9993     default:
9994       if (type >= STT_LOPROC && type <= STT_HIPROC)
9995         {
9996           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9997             return "THUMB_FUNC";
9998
9999           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10000             return "REGISTER";
10001
10002           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10003             return "PARISC_MILLI";
10004
10005           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10006         }
10007       else if (type >= STT_LOOS && type <= STT_HIOS)
10008         {
10009           if (elf_header.e_machine == EM_PARISC)
10010             {
10011               if (type == STT_HP_OPAQUE)
10012                 return "HP_OPAQUE";
10013               if (type == STT_HP_STUB)
10014                 return "HP_STUB";
10015             }
10016
10017           if (type == STT_GNU_IFUNC
10018               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10019                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10020                   /* GNU is still using the default value 0.  */
10021                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10022             return "IFUNC";
10023
10024           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10025         }
10026       else
10027         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10028       return buff;
10029     }
10030 }
10031
10032 static const char *
10033 get_symbol_visibility (unsigned int visibility)
10034 {
10035   switch (visibility)
10036     {
10037     case STV_DEFAULT:   return "DEFAULT";
10038     case STV_INTERNAL:  return "INTERNAL";
10039     case STV_HIDDEN:    return "HIDDEN";
10040     case STV_PROTECTED: return "PROTECTED";
10041     default:
10042       error (_("Unrecognized visibility value: %u"), visibility);
10043       return _("<unknown>");
10044     }
10045 }
10046
10047 static const char *
10048 get_mips_symbol_other (unsigned int other)
10049 {
10050   switch (other)
10051     {
10052     case STO_OPTIONAL:
10053       return "OPTIONAL";
10054     case STO_MIPS_PLT:
10055       return "MIPS PLT";
10056     case STO_MIPS_PIC:
10057       return "MIPS PIC";
10058     case STO_MICROMIPS:
10059       return "MICROMIPS";
10060     case STO_MICROMIPS | STO_MIPS_PIC:
10061       return "MICROMIPS, MIPS PIC";
10062     case STO_MIPS16:
10063       return "MIPS16";
10064     default:
10065       return NULL;
10066     }
10067 }
10068
10069 static const char *
10070 get_ia64_symbol_other (unsigned int other)
10071 {
10072   if (is_ia64_vms ())
10073     {
10074       static char res[32];
10075
10076       res[0] = 0;
10077
10078       /* Function types is for images and .STB files only.  */
10079       switch (elf_header.e_type)
10080         {
10081         case ET_DYN:
10082         case ET_EXEC:
10083           switch (VMS_ST_FUNC_TYPE (other))
10084             {
10085             case VMS_SFT_CODE_ADDR:
10086               strcat (res, " CA");
10087               break;
10088             case VMS_SFT_SYMV_IDX:
10089               strcat (res, " VEC");
10090               break;
10091             case VMS_SFT_FD:
10092               strcat (res, " FD");
10093               break;
10094             case VMS_SFT_RESERVE:
10095               strcat (res, " RSV");
10096               break;
10097             default:
10098               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10099                     VMS_ST_FUNC_TYPE (other));
10100               strcat (res, " <unknown>");
10101               break;
10102             }
10103           break;
10104         default:
10105           break;
10106         }
10107       switch (VMS_ST_LINKAGE (other))
10108         {
10109         case VMS_STL_IGNORE:
10110           strcat (res, " IGN");
10111           break;
10112         case VMS_STL_RESERVE:
10113           strcat (res, " RSV");
10114           break;
10115         case VMS_STL_STD:
10116           strcat (res, " STD");
10117           break;
10118         case VMS_STL_LNK:
10119           strcat (res, " LNK");
10120           break;
10121         default:
10122           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10123                 VMS_ST_LINKAGE (other));
10124           strcat (res, " <unknown>");
10125           break;
10126         }
10127
10128       if (res[0] != 0)
10129         return res + 1;
10130       else
10131         return res;
10132     }
10133   return NULL;
10134 }
10135
10136 static const char *
10137 get_ppc64_symbol_other (unsigned int other)
10138 {
10139   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10140     {
10141       static char buf[32];
10142       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10143                 PPC64_LOCAL_ENTRY_OFFSET (other));
10144       return buf;
10145     }
10146   return NULL;
10147 }
10148
10149 static const char *
10150 get_symbol_other (unsigned int other)
10151 {
10152   const char * result = NULL;
10153   static char buff [32];
10154
10155   if (other == 0)
10156     return "";
10157
10158   switch (elf_header.e_machine)
10159     {
10160     case EM_MIPS:
10161       result = get_mips_symbol_other (other);
10162       break;
10163     case EM_IA_64:
10164       result = get_ia64_symbol_other (other);
10165       break;
10166     case EM_PPC64:
10167       result = get_ppc64_symbol_other (other);
10168       break;
10169     default:
10170       break;
10171     }
10172
10173   if (result)
10174     return result;
10175
10176   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10177   return buff;
10178 }
10179
10180 static const char *
10181 get_symbol_index_type (unsigned int type)
10182 {
10183   static char buff[32];
10184
10185   switch (type)
10186     {
10187     case SHN_UNDEF:     return "UND";
10188     case SHN_ABS:       return "ABS";
10189     case SHN_COMMON:    return "COM";
10190     default:
10191       if (type == SHN_IA_64_ANSI_COMMON
10192           && elf_header.e_machine == EM_IA_64
10193           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10194         return "ANSI_COM";
10195       else if ((elf_header.e_machine == EM_X86_64
10196                 || elf_header.e_machine == EM_L1OM
10197                 || elf_header.e_machine == EM_K1OM)
10198                && type == SHN_X86_64_LCOMMON)
10199         return "LARGE_COM";
10200       else if ((type == SHN_MIPS_SCOMMON
10201                 && elf_header.e_machine == EM_MIPS)
10202                || (type == SHN_TIC6X_SCOMMON
10203                    && elf_header.e_machine == EM_TI_C6000))
10204         return "SCOM";
10205       else if (type == SHN_MIPS_SUNDEFINED
10206                && elf_header.e_machine == EM_MIPS)
10207         return "SUND";
10208       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10209         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10210       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10211         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10212       else if (type >= SHN_LORESERVE)
10213         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10214       else if (type >= elf_header.e_shnum)
10215         sprintf (buff, _("bad section index[%3d]"), type);
10216       else
10217         sprintf (buff, "%3d", type);
10218       break;
10219     }
10220
10221   return buff;
10222 }
10223
10224 static bfd_vma *
10225 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10226 {
10227   unsigned char * e_data;
10228   bfd_vma * i_data;
10229
10230   /* If the size_t type is smaller than the bfd_size_type, eg because
10231      you are building a 32-bit tool on a 64-bit host, then make sure
10232      that when (number) is cast to (size_t) no information is lost.  */
10233   if (sizeof (size_t) < sizeof (bfd_size_type)
10234       && (bfd_size_type) ((size_t) number) != number)
10235     {
10236       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10237              (unsigned long long) number, ent_size);
10238       return NULL;
10239     }
10240
10241   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10242      attempting to allocate memory when the read is bound to fail.  */
10243   if (ent_size * number > current_file_size)
10244     {
10245       error (_("Invalid number of dynamic entries: %llu\n"),
10246              (unsigned long long) number);
10247       return NULL;
10248     }
10249
10250   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10251   if (e_data == NULL)
10252     {
10253       error (_("Out of memory reading %llu dynamic entries\n"),
10254              (unsigned long long) number);
10255       return NULL;
10256     }
10257
10258   if (fread (e_data, ent_size, (size_t) number, file) != number)
10259     {
10260       error (_("Unable to read in %llu bytes of dynamic data\n"),
10261              (unsigned long long) (number * ent_size));
10262       free (e_data);
10263       return NULL;
10264     }
10265
10266   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10267   if (i_data == NULL)
10268     {
10269       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10270              (unsigned long long) number);
10271       free (e_data);
10272       return NULL;
10273     }
10274
10275   while (number--)
10276     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10277
10278   free (e_data);
10279
10280   return i_data;
10281 }
10282
10283 static void
10284 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10285 {
10286   Elf_Internal_Sym * psym;
10287   int n;
10288
10289   n = print_vma (si, DEC_5);
10290   if (n < 5)
10291     fputs (&"     "[n], stdout);
10292   printf (" %3lu: ", hn);
10293
10294   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10295     {
10296       printf (_("<No info available for dynamic symbol number %lu>\n"),
10297               (unsigned long) si);
10298       return;
10299     }
10300
10301   psym = dynamic_symbols + si;
10302   print_vma (psym->st_value, LONG_HEX);
10303   putchar (' ');
10304   print_vma (psym->st_size, DEC_5);
10305
10306   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10307   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10308   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10309   /* Check to see if any other bits in the st_other field are set.
10310      Note - displaying this information disrupts the layout of the
10311      table being generated, but for the moment this case is very
10312      rare.  */
10313   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10314     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10315   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10316   if (VALID_DYNAMIC_NAME (psym->st_name))
10317     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10318   else
10319     printf (_(" <corrupt: %14ld>"), psym->st_name);
10320   putchar ('\n');
10321 }
10322
10323 static const char *
10324 get_symbol_version_string (FILE *file, int is_dynsym,
10325                            const char *strtab,
10326                            unsigned long int strtab_size,
10327                            unsigned int si, Elf_Internal_Sym *psym,
10328                            enum versioned_symbol_info *sym_info,
10329                            unsigned short *vna_other)
10330 {
10331   const char *version_string = NULL;
10332
10333   if (is_dynsym
10334       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10335     {
10336       unsigned char data[2];
10337       unsigned short vers_data;
10338       unsigned long offset;
10339       int is_nobits;
10340       int check_def;
10341
10342       offset = offset_from_vma
10343         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10344          sizeof data + si * sizeof (vers_data));
10345
10346       if (get_data (&data, file, offset + si * sizeof (vers_data),
10347                     sizeof (data), 1, _("version data")) == NULL)
10348         return NULL;
10349
10350       vers_data = byte_get (data, 2);
10351
10352       is_nobits = (section_headers != NULL
10353                    && psym->st_shndx < elf_header.e_shnum
10354                    && section_headers[psym->st_shndx].sh_type
10355                    == SHT_NOBITS);
10356
10357       check_def = (psym->st_shndx != SHN_UNDEF);
10358
10359       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10360         {
10361           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10362               && (is_nobits || ! check_def))
10363             {
10364               Elf_External_Verneed evn;
10365               Elf_Internal_Verneed ivn;
10366               Elf_Internal_Vernaux ivna;
10367
10368               /* We must test both.  */
10369               offset = offset_from_vma
10370                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10371                  sizeof evn);
10372
10373               do
10374                 {
10375                   unsigned long vna_off;
10376
10377                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10378                                 _("version need")) == NULL)
10379                     {
10380                       ivna.vna_next = 0;
10381                       ivna.vna_other = 0;
10382                       ivna.vna_name = 0;
10383                       break;
10384                     }
10385
10386                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10387                   ivn.vn_next = BYTE_GET (evn.vn_next);
10388
10389                   vna_off = offset + ivn.vn_aux;
10390
10391                   do
10392                     {
10393                       Elf_External_Vernaux evna;
10394
10395                       if (get_data (&evna, file, vna_off,
10396                                     sizeof (evna), 1,
10397                                     _("version need aux (3)")) == NULL)
10398                         {
10399                           ivna.vna_next = 0;
10400                           ivna.vna_other = 0;
10401                           ivna.vna_name = 0;
10402                         }
10403                       else
10404                         {
10405                           ivna.vna_other = BYTE_GET (evna.vna_other);
10406                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10407                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10408                         }
10409
10410                       vna_off += ivna.vna_next;
10411                     }
10412                   while (ivna.vna_other != vers_data
10413                          && ivna.vna_next != 0);
10414
10415                   if (ivna.vna_other == vers_data)
10416                     break;
10417
10418                   offset += ivn.vn_next;
10419                 }
10420               while (ivn.vn_next != 0);
10421
10422               if (ivna.vna_other == vers_data)
10423                 {
10424                   *sym_info = symbol_undefined;
10425                   *vna_other = ivna.vna_other;
10426                   version_string = (ivna.vna_name < strtab_size
10427                                     ? strtab + ivna.vna_name
10428                                     : _("<corrupt>"));
10429                   check_def = 0;
10430                 }
10431               else if (! is_nobits)
10432                 error (_("bad dynamic symbol\n"));
10433               else
10434                 check_def = 1;
10435             }
10436
10437           if (check_def)
10438             {
10439               if (vers_data != 0x8001
10440                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10441                 {
10442                   Elf_Internal_Verdef ivd;
10443                   Elf_Internal_Verdaux ivda;
10444                   Elf_External_Verdaux evda;
10445                   unsigned long off;
10446
10447                   off = offset_from_vma
10448                     (file,
10449                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10450                      sizeof (Elf_External_Verdef));
10451
10452                   do
10453                     {
10454                       Elf_External_Verdef evd;
10455
10456                       if (get_data (&evd, file, off, sizeof (evd),
10457                                     1, _("version def")) == NULL)
10458                         {
10459                           ivd.vd_ndx = 0;
10460                           ivd.vd_aux = 0;
10461                           ivd.vd_next = 0;
10462                         }
10463                       else
10464                         {
10465                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10466                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10467                           ivd.vd_next = BYTE_GET (evd.vd_next);
10468                         }
10469
10470                       off += ivd.vd_next;
10471                     }
10472                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10473                          && ivd.vd_next != 0);
10474
10475                   off -= ivd.vd_next;
10476                   off += ivd.vd_aux;
10477
10478                   if (get_data (&evda, file, off, sizeof (evda),
10479                                 1, _("version def aux")) == NULL)
10480                     return version_string;
10481
10482                   ivda.vda_name = BYTE_GET (evda.vda_name);
10483
10484                   if (psym->st_name != ivda.vda_name)
10485                     {
10486                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10487                                    ? symbol_hidden : symbol_public);
10488                       version_string = (ivda.vda_name < strtab_size
10489                                         ? strtab + ivda.vda_name
10490                                         : _("<corrupt>"));
10491                     }
10492                 }
10493             }
10494         }
10495     }
10496   return version_string;
10497 }
10498
10499 /* Dump the symbol table.  */
10500 static int
10501 process_symbol_table (FILE * file)
10502 {
10503   Elf_Internal_Shdr * section;
10504   bfd_size_type nbuckets = 0;
10505   bfd_size_type nchains = 0;
10506   bfd_vma * buckets = NULL;
10507   bfd_vma * chains = NULL;
10508   bfd_vma ngnubuckets = 0;
10509   bfd_vma * gnubuckets = NULL;
10510   bfd_vma * gnuchains = NULL;
10511   bfd_vma gnusymidx = 0;
10512   bfd_size_type ngnuchains = 0;
10513
10514   if (!do_syms && !do_dyn_syms && !do_histogram)
10515     return 1;
10516
10517   if (dynamic_info[DT_HASH]
10518       && (do_histogram
10519           || (do_using_dynamic
10520               && !do_dyn_syms
10521               && dynamic_strings != NULL)))
10522     {
10523       unsigned char nb[8];
10524       unsigned char nc[8];
10525       unsigned int hash_ent_size = 4;
10526
10527       if ((elf_header.e_machine == EM_ALPHA
10528            || elf_header.e_machine == EM_S390
10529            || elf_header.e_machine == EM_S390_OLD)
10530           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10531         hash_ent_size = 8;
10532
10533       if (fseek (file,
10534                  (archive_file_offset
10535                   + offset_from_vma (file, dynamic_info[DT_HASH],
10536                                      sizeof nb + sizeof nc)),
10537                  SEEK_SET))
10538         {
10539           error (_("Unable to seek to start of dynamic information\n"));
10540           goto no_hash;
10541         }
10542
10543       if (fread (nb, hash_ent_size, 1, file) != 1)
10544         {
10545           error (_("Failed to read in number of buckets\n"));
10546           goto no_hash;
10547         }
10548
10549       if (fread (nc, hash_ent_size, 1, file) != 1)
10550         {
10551           error (_("Failed to read in number of chains\n"));
10552           goto no_hash;
10553         }
10554
10555       nbuckets = byte_get (nb, hash_ent_size);
10556       nchains  = byte_get (nc, hash_ent_size);
10557
10558       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10559       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10560
10561     no_hash:
10562       if (buckets == NULL || chains == NULL)
10563         {
10564           if (do_using_dynamic)
10565             return 0;
10566           free (buckets);
10567           free (chains);
10568           buckets = NULL;
10569           chains = NULL;
10570           nbuckets = 0;
10571           nchains = 0;
10572         }
10573     }
10574
10575   if (dynamic_info_DT_GNU_HASH
10576       && (do_histogram
10577           || (do_using_dynamic
10578               && !do_dyn_syms
10579               && dynamic_strings != NULL)))
10580     {
10581       unsigned char nb[16];
10582       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10583       bfd_vma buckets_vma;
10584
10585       if (fseek (file,
10586                  (archive_file_offset
10587                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10588                                      sizeof nb)),
10589                  SEEK_SET))
10590         {
10591           error (_("Unable to seek to start of dynamic information\n"));
10592           goto no_gnu_hash;
10593         }
10594
10595       if (fread (nb, 16, 1, file) != 1)
10596         {
10597           error (_("Failed to read in number of buckets\n"));
10598           goto no_gnu_hash;
10599         }
10600
10601       ngnubuckets = byte_get (nb, 4);
10602       gnusymidx = byte_get (nb + 4, 4);
10603       bitmaskwords = byte_get (nb + 8, 4);
10604       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10605       if (is_32bit_elf)
10606         buckets_vma += bitmaskwords * 4;
10607       else
10608         buckets_vma += bitmaskwords * 8;
10609
10610       if (fseek (file,
10611                  (archive_file_offset
10612                   + offset_from_vma (file, buckets_vma, 4)),
10613                  SEEK_SET))
10614         {
10615           error (_("Unable to seek to start of dynamic information\n"));
10616           goto no_gnu_hash;
10617         }
10618
10619       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10620
10621       if (gnubuckets == NULL)
10622         goto no_gnu_hash;
10623
10624       for (i = 0; i < ngnubuckets; i++)
10625         if (gnubuckets[i] != 0)
10626           {
10627             if (gnubuckets[i] < gnusymidx)
10628               return 0;
10629
10630             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10631               maxchain = gnubuckets[i];
10632           }
10633
10634       if (maxchain == 0xffffffff)
10635         goto no_gnu_hash;
10636
10637       maxchain -= gnusymidx;
10638
10639       if (fseek (file,
10640                  (archive_file_offset
10641                   + offset_from_vma (file, buckets_vma
10642                                            + 4 * (ngnubuckets + maxchain), 4)),
10643                  SEEK_SET))
10644         {
10645           error (_("Unable to seek to start of dynamic information\n"));
10646           goto no_gnu_hash;
10647         }
10648
10649       do
10650         {
10651           if (fread (nb, 4, 1, file) != 1)
10652             {
10653               error (_("Failed to determine last chain length\n"));
10654               goto no_gnu_hash;
10655             }
10656
10657           if (maxchain + 1 == 0)
10658             goto no_gnu_hash;
10659
10660           ++maxchain;
10661         }
10662       while ((byte_get (nb, 4) & 1) == 0);
10663
10664       if (fseek (file,
10665                  (archive_file_offset
10666                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10667                  SEEK_SET))
10668         {
10669           error (_("Unable to seek to start of dynamic information\n"));
10670           goto no_gnu_hash;
10671         }
10672
10673       gnuchains = get_dynamic_data (file, maxchain, 4);
10674       ngnuchains = maxchain;
10675
10676     no_gnu_hash:
10677       if (gnuchains == NULL)
10678         {
10679           free (gnubuckets);
10680           gnubuckets = NULL;
10681           ngnubuckets = 0;
10682           if (do_using_dynamic)
10683             return 0;
10684         }
10685     }
10686
10687   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10688       && do_syms
10689       && do_using_dynamic
10690       && dynamic_strings != NULL
10691       && dynamic_symbols != NULL)
10692     {
10693       unsigned long hn;
10694
10695       if (dynamic_info[DT_HASH])
10696         {
10697           bfd_vma si;
10698
10699           printf (_("\nSymbol table for image:\n"));
10700           if (is_32bit_elf)
10701             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10702           else
10703             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10704
10705           for (hn = 0; hn < nbuckets; hn++)
10706             {
10707               if (! buckets[hn])
10708                 continue;
10709
10710               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10711                 print_dynamic_symbol (si, hn);
10712             }
10713         }
10714
10715       if (dynamic_info_DT_GNU_HASH)
10716         {
10717           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10718           if (is_32bit_elf)
10719             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10720           else
10721             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10722
10723           for (hn = 0; hn < ngnubuckets; ++hn)
10724             if (gnubuckets[hn] != 0)
10725               {
10726                 bfd_vma si = gnubuckets[hn];
10727                 bfd_vma off = si - gnusymidx;
10728
10729                 do
10730                   {
10731                     print_dynamic_symbol (si, hn);
10732                     si++;
10733                   }
10734                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10735               }
10736         }
10737     }
10738   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10739            && section_headers != NULL)
10740     {
10741       unsigned int i;
10742
10743       for (i = 0, section = section_headers;
10744            i < elf_header.e_shnum;
10745            i++, section++)
10746         {
10747           unsigned int si;
10748           char * strtab = NULL;
10749           unsigned long int strtab_size = 0;
10750           Elf_Internal_Sym * symtab;
10751           Elf_Internal_Sym * psym;
10752           unsigned long num_syms;
10753
10754           if ((section->sh_type != SHT_SYMTAB
10755                && section->sh_type != SHT_DYNSYM)
10756               || (!do_syms
10757                   && section->sh_type == SHT_SYMTAB))
10758             continue;
10759
10760           if (section->sh_entsize == 0)
10761             {
10762               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10763                       printable_section_name (section));
10764               continue;
10765             }
10766
10767           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10768                   printable_section_name (section),
10769                   (unsigned long) (section->sh_size / section->sh_entsize));
10770
10771           if (is_32bit_elf)
10772             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10773           else
10774             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10775
10776           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10777           if (symtab == NULL)
10778             continue;
10779
10780           if (section->sh_link == elf_header.e_shstrndx)
10781             {
10782               strtab = string_table;
10783               strtab_size = string_table_length;
10784             }
10785           else if (section->sh_link < elf_header.e_shnum)
10786             {
10787               Elf_Internal_Shdr * string_sec;
10788
10789               string_sec = section_headers + section->sh_link;
10790
10791               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10792                                           1, string_sec->sh_size,
10793                                           _("string table"));
10794               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10795             }
10796
10797           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10798             {
10799               const char *version_string;
10800               enum versioned_symbol_info sym_info;
10801               unsigned short vna_other;
10802
10803               printf ("%6d: ", si);
10804               print_vma (psym->st_value, LONG_HEX);
10805               putchar (' ');
10806               print_vma (psym->st_size, DEC_5);
10807               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10808               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10809               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10810               /* Check to see if any other bits in the st_other field are set.
10811                  Note - displaying this information disrupts the layout of the
10812                  table being generated, but for the moment this case is very rare.  */
10813               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10814                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10815               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10816               print_symbol (25, psym->st_name < strtab_size
10817                             ? strtab + psym->st_name : _("<corrupt>"));
10818
10819               version_string
10820                 = get_symbol_version_string (file,
10821                                              section->sh_type == SHT_DYNSYM,
10822                                              strtab, strtab_size, si,
10823                                              psym, &sym_info, &vna_other);
10824               if (version_string)
10825                 {
10826                   if (sym_info == symbol_undefined)
10827                     printf ("@%s (%d)", version_string, vna_other);
10828                   else
10829                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10830                             version_string);
10831                 }
10832
10833               putchar ('\n');
10834             }
10835
10836           free (symtab);
10837           if (strtab != string_table)
10838             free (strtab);
10839         }
10840     }
10841   else if (do_syms)
10842     printf
10843       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10844
10845   if (do_histogram && buckets != NULL)
10846     {
10847       unsigned long * lengths;
10848       unsigned long * counts;
10849       unsigned long hn;
10850       bfd_vma si;
10851       unsigned long maxlength = 0;
10852       unsigned long nzero_counts = 0;
10853       unsigned long nsyms = 0;
10854       unsigned long chained;
10855
10856       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10857               (unsigned long) nbuckets);
10858
10859       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10860       if (lengths == NULL)
10861         {
10862           error (_("Out of memory allocating space for histogram buckets\n"));
10863           return 0;
10864         }
10865
10866       printf (_(" Length  Number     %% of total  Coverage\n"));
10867       for (hn = 0; hn < nbuckets; ++hn)
10868         {
10869           for (si = buckets[hn], chained = 0;
10870                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10871                si = chains[si], ++chained)
10872             {
10873               ++nsyms;
10874               if (maxlength < ++lengths[hn])
10875                 ++maxlength;
10876             }
10877
10878             /* PR binutils/17531: A corrupt binary could contain broken
10879                histogram data.  Do not go into an infinite loop trying
10880                to process it.  */
10881             if (chained > nchains)
10882               {
10883                 error (_("histogram chain is corrupt\n"));
10884                 break;
10885               }
10886         }
10887
10888       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10889       if (counts == NULL)
10890         {
10891           free (lengths);
10892           error (_("Out of memory allocating space for histogram counts\n"));
10893           return 0;
10894         }
10895
10896       for (hn = 0; hn < nbuckets; ++hn)
10897         ++counts[lengths[hn]];
10898
10899       if (nbuckets > 0)
10900         {
10901           unsigned long i;
10902           printf ("      0  %-10lu (%5.1f%%)\n",
10903                   counts[0], (counts[0] * 100.0) / nbuckets);
10904           for (i = 1; i <= maxlength; ++i)
10905             {
10906               nzero_counts += counts[i] * i;
10907               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10908                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10909                       (nzero_counts * 100.0) / nsyms);
10910             }
10911         }
10912
10913       free (counts);
10914       free (lengths);
10915     }
10916
10917   if (buckets != NULL)
10918     {
10919       free (buckets);
10920       free (chains);
10921     }
10922
10923   if (do_histogram && gnubuckets != NULL)
10924     {
10925       unsigned long * lengths;
10926       unsigned long * counts;
10927       unsigned long hn;
10928       unsigned long maxlength = 0;
10929       unsigned long nzero_counts = 0;
10930       unsigned long nsyms = 0;
10931
10932       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10933               (unsigned long) ngnubuckets);
10934
10935       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10936       if (lengths == NULL)
10937         {
10938           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10939           return 0;
10940         }
10941
10942       printf (_(" Length  Number     %% of total  Coverage\n"));
10943
10944       for (hn = 0; hn < ngnubuckets; ++hn)
10945         if (gnubuckets[hn] != 0)
10946           {
10947             bfd_vma off, length = 1;
10948
10949             for (off = gnubuckets[hn] - gnusymidx;
10950                  /* PR 17531 file: 010-77222-0.004.  */
10951                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10952                  ++off)
10953               ++length;
10954             lengths[hn] = length;
10955             if (length > maxlength)
10956               maxlength = length;
10957             nsyms += length;
10958           }
10959
10960       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10961       if (counts == NULL)
10962         {
10963           free (lengths);
10964           error (_("Out of memory allocating space for gnu histogram counts\n"));
10965           return 0;
10966         }
10967
10968       for (hn = 0; hn < ngnubuckets; ++hn)
10969         ++counts[lengths[hn]];
10970
10971       if (ngnubuckets > 0)
10972         {
10973           unsigned long j;
10974           printf ("      0  %-10lu (%5.1f%%)\n",
10975                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10976           for (j = 1; j <= maxlength; ++j)
10977             {
10978               nzero_counts += counts[j] * j;
10979               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10980                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10981                       (nzero_counts * 100.0) / nsyms);
10982             }
10983         }
10984
10985       free (counts);
10986       free (lengths);
10987       free (gnubuckets);
10988       free (gnuchains);
10989     }
10990
10991   return 1;
10992 }
10993
10994 static int
10995 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10996 {
10997   unsigned int i;
10998
10999   if (dynamic_syminfo == NULL
11000       || !do_dynamic)
11001     /* No syminfo, this is ok.  */
11002     return 1;
11003
11004   /* There better should be a dynamic symbol section.  */
11005   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11006     return 0;
11007
11008   if (dynamic_addr)
11009     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11010             dynamic_syminfo_offset, dynamic_syminfo_nent);
11011
11012   printf (_(" Num: Name                           BoundTo     Flags\n"));
11013   for (i = 0; i < dynamic_syminfo_nent; ++i)
11014     {
11015       unsigned short int flags = dynamic_syminfo[i].si_flags;
11016
11017       printf ("%4d: ", i);
11018       if (i >= num_dynamic_syms)
11019         printf (_("<corrupt index>"));
11020       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11021         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11022       else
11023         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11024       putchar (' ');
11025
11026       switch (dynamic_syminfo[i].si_boundto)
11027         {
11028         case SYMINFO_BT_SELF:
11029           fputs ("SELF       ", stdout);
11030           break;
11031         case SYMINFO_BT_PARENT:
11032           fputs ("PARENT     ", stdout);
11033           break;
11034         default:
11035           if (dynamic_syminfo[i].si_boundto > 0
11036               && dynamic_syminfo[i].si_boundto < dynamic_nent
11037               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11038             {
11039               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11040               putchar (' ' );
11041             }
11042           else
11043             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11044           break;
11045         }
11046
11047       if (flags & SYMINFO_FLG_DIRECT)
11048         printf (" DIRECT");
11049       if (flags & SYMINFO_FLG_PASSTHRU)
11050         printf (" PASSTHRU");
11051       if (flags & SYMINFO_FLG_COPY)
11052         printf (" COPY");
11053       if (flags & SYMINFO_FLG_LAZYLOAD)
11054         printf (" LAZYLOAD");
11055
11056       puts ("");
11057     }
11058
11059   return 1;
11060 }
11061
11062 /* Check to see if the given reloc needs to be handled in a target specific
11063    manner.  If so then process the reloc and return TRUE otherwise return
11064    FALSE.  */
11065
11066 static bfd_boolean
11067 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11068                                 unsigned char *     start,
11069                                 Elf_Internal_Sym *  symtab)
11070 {
11071   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11072
11073   switch (elf_header.e_machine)
11074     {
11075     case EM_MSP430:
11076     case EM_MSP430_OLD:
11077       {
11078         static Elf_Internal_Sym * saved_sym = NULL;
11079
11080         switch (reloc_type)
11081           {
11082           case 10: /* R_MSP430_SYM_DIFF */
11083             if (uses_msp430x_relocs ())
11084               break;
11085           case 21: /* R_MSP430X_SYM_DIFF */
11086             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11087             return TRUE;
11088
11089           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11090           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11091             goto handle_sym_diff;
11092
11093           case 5: /* R_MSP430_16_BYTE */
11094           case 9: /* R_MSP430_8 */
11095             if (uses_msp430x_relocs ())
11096               break;
11097             goto handle_sym_diff;
11098
11099           case 2: /* R_MSP430_ABS16 */
11100           case 15: /* R_MSP430X_ABS16 */
11101             if (! uses_msp430x_relocs ())
11102               break;
11103             goto handle_sym_diff;
11104
11105           handle_sym_diff:
11106             if (saved_sym != NULL)
11107               {
11108                 bfd_vma value;
11109
11110                 value = reloc->r_addend
11111                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11112                      - saved_sym->st_value);
11113
11114                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11115
11116                 saved_sym = NULL;
11117                 return TRUE;
11118               }
11119             break;
11120
11121           default:
11122             if (saved_sym != NULL)
11123               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11124             break;
11125           }
11126         break;
11127       }
11128
11129     case EM_MN10300:
11130     case EM_CYGNUS_MN10300:
11131       {
11132         static Elf_Internal_Sym * saved_sym = NULL;
11133
11134         switch (reloc_type)
11135           {
11136           case 34: /* R_MN10300_ALIGN */
11137             return TRUE;
11138           case 33: /* R_MN10300_SYM_DIFF */
11139             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11140             return TRUE;
11141           case 1: /* R_MN10300_32 */
11142           case 2: /* R_MN10300_16 */
11143             if (saved_sym != NULL)
11144               {
11145                 bfd_vma value;
11146
11147                 value = reloc->r_addend
11148                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11149                      - saved_sym->st_value);
11150
11151                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11152
11153                 saved_sym = NULL;
11154                 return TRUE;
11155               }
11156             break;
11157           default:
11158             if (saved_sym != NULL)
11159               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11160             break;
11161           }
11162         break;
11163       }
11164
11165     case EM_RL78:
11166       {
11167         static bfd_vma saved_sym1 = 0;
11168         static bfd_vma saved_sym2 = 0;
11169         static bfd_vma value;
11170
11171         switch (reloc_type)
11172           {
11173           case 0x80: /* R_RL78_SYM.  */
11174             saved_sym1 = saved_sym2;
11175             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11176             saved_sym2 += reloc->r_addend;
11177             return TRUE;
11178
11179           case 0x83: /* R_RL78_OPsub.  */
11180             value = saved_sym1 - saved_sym2;
11181             saved_sym2 = saved_sym1 = 0;
11182             return TRUE;
11183             break;
11184
11185           case 0x41: /* R_RL78_ABS32.  */
11186             byte_put (start + reloc->r_offset, value, 4);
11187             value = 0;
11188             return TRUE;
11189
11190           case 0x43: /* R_RL78_ABS16.  */
11191             byte_put (start + reloc->r_offset, value, 2);
11192             value = 0;
11193             return TRUE;
11194
11195           default:
11196             break;
11197           }
11198         break;
11199       }
11200     }
11201
11202   return FALSE;
11203 }
11204
11205 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11206    DWARF debug sections.  This is a target specific test.  Note - we do not
11207    go through the whole including-target-headers-multiple-times route, (as
11208    we have already done with <elf/h8.h>) because this would become very
11209    messy and even then this function would have to contain target specific
11210    information (the names of the relocs instead of their numeric values).
11211    FIXME: This is not the correct way to solve this problem.  The proper way
11212    is to have target specific reloc sizing and typing functions created by
11213    the reloc-macros.h header, in the same way that it already creates the
11214    reloc naming functions.  */
11215
11216 static bfd_boolean
11217 is_32bit_abs_reloc (unsigned int reloc_type)
11218 {
11219   switch (elf_header.e_machine)
11220     {
11221     case EM_386:
11222     case EM_486:
11223       return reloc_type == 1; /* R_386_32.  */
11224     case EM_68K:
11225       return reloc_type == 1; /* R_68K_32.  */
11226     case EM_860:
11227       return reloc_type == 1; /* R_860_32.  */
11228     case EM_960:
11229       return reloc_type == 2; /* R_960_32.  */
11230     case EM_AARCH64:
11231       return reloc_type == 258; /* R_AARCH64_ABS32 */
11232     case EM_ALPHA:
11233       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11234     case EM_ARC:
11235       return reloc_type == 1; /* R_ARC_32.  */
11236     case EM_ARM:
11237       return reloc_type == 2; /* R_ARM_ABS32 */
11238     case EM_AVR_OLD:
11239     case EM_AVR:
11240       return reloc_type == 1;
11241     case EM_ADAPTEVA_EPIPHANY:
11242       return reloc_type == 3;
11243     case EM_BLACKFIN:
11244       return reloc_type == 0x12; /* R_byte4_data.  */
11245     case EM_CRIS:
11246       return reloc_type == 3; /* R_CRIS_32.  */
11247     case EM_CR16:
11248       return reloc_type == 3; /* R_CR16_NUM32.  */
11249     case EM_CRX:
11250       return reloc_type == 15; /* R_CRX_NUM32.  */
11251     case EM_CYGNUS_FRV:
11252       return reloc_type == 1;
11253     case EM_CYGNUS_D10V:
11254     case EM_D10V:
11255       return reloc_type == 6; /* R_D10V_32.  */
11256     case EM_CYGNUS_D30V:
11257     case EM_D30V:
11258       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11259     case EM_DLX:
11260       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11261     case EM_CYGNUS_FR30:
11262     case EM_FR30:
11263       return reloc_type == 3; /* R_FR30_32.  */
11264     case EM_FT32:
11265       return reloc_type == 1; /* R_FT32_32.  */
11266     case EM_H8S:
11267     case EM_H8_300:
11268     case EM_H8_300H:
11269       return reloc_type == 1; /* R_H8_DIR32.  */
11270     case EM_IA_64:
11271       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
11272     case EM_IP2K_OLD:
11273     case EM_IP2K:
11274       return reloc_type == 2; /* R_IP2K_32.  */
11275     case EM_IQ2000:
11276       return reloc_type == 2; /* R_IQ2000_32.  */
11277     case EM_LATTICEMICO32:
11278       return reloc_type == 3; /* R_LM32_32.  */
11279     case EM_M32C_OLD:
11280     case EM_M32C:
11281       return reloc_type == 3; /* R_M32C_32.  */
11282     case EM_M32R:
11283       return reloc_type == 34; /* R_M32R_32_RELA.  */
11284     case EM_MCORE:
11285       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11286     case EM_CYGNUS_MEP:
11287       return reloc_type == 4; /* R_MEP_32.  */
11288     case EM_METAG:
11289       return reloc_type == 2; /* R_METAG_ADDR32.  */
11290     case EM_MICROBLAZE:
11291       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11292     case EM_MIPS:
11293       return reloc_type == 2; /* R_MIPS_32.  */
11294     case EM_MMIX:
11295       return reloc_type == 4; /* R_MMIX_32.  */
11296     case EM_CYGNUS_MN10200:
11297     case EM_MN10200:
11298       return reloc_type == 1; /* R_MN10200_32.  */
11299     case EM_CYGNUS_MN10300:
11300     case EM_MN10300:
11301       return reloc_type == 1; /* R_MN10300_32.  */
11302     case EM_MOXIE:
11303       return reloc_type == 1; /* R_MOXIE_32.  */
11304     case EM_MSP430_OLD:
11305     case EM_MSP430:
11306       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11307     case EM_MT:
11308       return reloc_type == 2; /* R_MT_32.  */
11309     case EM_NDS32:
11310       return reloc_type == 20; /* R_NDS32_RELA.  */
11311     case EM_ALTERA_NIOS2:
11312       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11313     case EM_NIOS32:
11314       return reloc_type == 1; /* R_NIOS_32.  */
11315     case EM_OR1K:
11316       return reloc_type == 1; /* R_OR1K_32.  */
11317     case EM_PARISC:
11318       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11319               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11320     case EM_PJ:
11321     case EM_PJ_OLD:
11322       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11323     case EM_PPC64:
11324       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11325     case EM_PPC:
11326       return reloc_type == 1; /* R_PPC_ADDR32.  */
11327     case EM_RL78:
11328       return reloc_type == 1; /* R_RL78_DIR32.  */
11329     case EM_RX:
11330       return reloc_type == 1; /* R_RX_DIR32.  */
11331     case EM_S370:
11332       return reloc_type == 1; /* R_I370_ADDR31.  */
11333     case EM_S390_OLD:
11334     case EM_S390:
11335       return reloc_type == 4; /* R_S390_32.  */
11336     case EM_SCORE:
11337       return reloc_type == 8; /* R_SCORE_ABS32.  */
11338     case EM_SH:
11339       return reloc_type == 1; /* R_SH_DIR32.  */
11340     case EM_SPARC32PLUS:
11341     case EM_SPARCV9:
11342     case EM_SPARC:
11343       return reloc_type == 3 /* R_SPARC_32.  */
11344         || reloc_type == 23; /* R_SPARC_UA32.  */
11345     case EM_SPU:
11346       return reloc_type == 6; /* R_SPU_ADDR32 */
11347     case EM_TI_C6000:
11348       return reloc_type == 1; /* R_C6000_ABS32.  */
11349     case EM_TILEGX:
11350       return reloc_type == 2; /* R_TILEGX_32.  */
11351     case EM_TILEPRO:
11352       return reloc_type == 1; /* R_TILEPRO_32.  */
11353     case EM_CYGNUS_V850:
11354     case EM_V850:
11355       return reloc_type == 6; /* R_V850_ABS32.  */
11356     case EM_V800:
11357       return reloc_type == 0x33; /* R_V810_WORD.  */
11358     case EM_VAX:
11359       return reloc_type == 1; /* R_VAX_32.  */
11360     case EM_VISIUM:
11361       return reloc_type == 3;  /* R_VISIUM_32. */
11362     case EM_X86_64:
11363     case EM_L1OM:
11364     case EM_K1OM:
11365       return reloc_type == 10; /* R_X86_64_32.  */
11366     case EM_XC16X:
11367     case EM_C166:
11368       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11369     case EM_XGATE:
11370       return reloc_type == 4; /* R_XGATE_32.  */
11371     case EM_XSTORMY16:
11372       return reloc_type == 1; /* R_XSTROMY16_32.  */
11373     case EM_XTENSA_OLD:
11374     case EM_XTENSA:
11375       return reloc_type == 1; /* R_XTENSA_32.  */
11376     default:
11377       {
11378         static unsigned int prev_warn = 0;
11379
11380         /* Avoid repeating the same warning multiple times.  */
11381         if (prev_warn != elf_header.e_machine)
11382           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11383                  elf_header.e_machine);
11384         prev_warn = elf_header.e_machine;
11385         return FALSE;
11386       }
11387     }
11388 }
11389
11390 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11391    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11392
11393 static bfd_boolean
11394 is_32bit_pcrel_reloc (unsigned int reloc_type)
11395 {
11396   switch (elf_header.e_machine)
11397     {
11398     case EM_386:
11399     case EM_486:
11400       return reloc_type == 2;  /* R_386_PC32.  */
11401     case EM_68K:
11402       return reloc_type == 4;  /* R_68K_PC32.  */
11403     case EM_AARCH64:
11404       return reloc_type == 261; /* R_AARCH64_PREL32 */
11405     case EM_ADAPTEVA_EPIPHANY:
11406       return reloc_type == 6;
11407     case EM_ALPHA:
11408       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11409     case EM_ARM:
11410       return reloc_type == 3;  /* R_ARM_REL32 */
11411     case EM_MICROBLAZE:
11412       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11413     case EM_OR1K:
11414       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11415     case EM_PARISC:
11416       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11417     case EM_PPC:
11418       return reloc_type == 26; /* R_PPC_REL32.  */
11419     case EM_PPC64:
11420       return reloc_type == 26; /* R_PPC64_REL32.  */
11421     case EM_S390_OLD:
11422     case EM_S390:
11423       return reloc_type == 5;  /* R_390_PC32.  */
11424     case EM_SH:
11425       return reloc_type == 2;  /* R_SH_REL32.  */
11426     case EM_SPARC32PLUS:
11427     case EM_SPARCV9:
11428     case EM_SPARC:
11429       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11430     case EM_SPU:
11431       return reloc_type == 13; /* R_SPU_REL32.  */
11432     case EM_TILEGX:
11433       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11434     case EM_TILEPRO:
11435       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11436     case EM_VISIUM:
11437       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11438     case EM_X86_64:
11439     case EM_L1OM:
11440     case EM_K1OM:
11441       return reloc_type == 2;  /* R_X86_64_PC32.  */
11442     case EM_XTENSA_OLD:
11443     case EM_XTENSA:
11444       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11445     default:
11446       /* Do not abort or issue an error message here.  Not all targets use
11447          pc-relative 32-bit relocs in their DWARF debug information and we
11448          have already tested for target coverage in is_32bit_abs_reloc.  A
11449          more helpful warning message will be generated by apply_relocations
11450          anyway, so just return.  */
11451       return FALSE;
11452     }
11453 }
11454
11455 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11456    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11457
11458 static bfd_boolean
11459 is_64bit_abs_reloc (unsigned int reloc_type)
11460 {
11461   switch (elf_header.e_machine)
11462     {
11463     case EM_AARCH64:
11464       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11465     case EM_ALPHA:
11466       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11467     case EM_IA_64:
11468       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11469     case EM_PARISC:
11470       return reloc_type == 80; /* R_PARISC_DIR64.  */
11471     case EM_PPC64:
11472       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11473     case EM_SPARC32PLUS:
11474     case EM_SPARCV9:
11475     case EM_SPARC:
11476       return reloc_type == 54; /* R_SPARC_UA64.  */
11477     case EM_X86_64:
11478     case EM_L1OM:
11479     case EM_K1OM:
11480       return reloc_type == 1; /* R_X86_64_64.  */
11481     case EM_S390_OLD:
11482     case EM_S390:
11483       return reloc_type == 22;  /* R_S390_64.  */
11484     case EM_TILEGX:
11485       return reloc_type == 1; /* R_TILEGX_64.  */
11486     case EM_MIPS:
11487       return reloc_type == 18;  /* R_MIPS_64.  */
11488     default:
11489       return FALSE;
11490     }
11491 }
11492
11493 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11494    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11495
11496 static bfd_boolean
11497 is_64bit_pcrel_reloc (unsigned int reloc_type)
11498 {
11499   switch (elf_header.e_machine)
11500     {
11501     case EM_AARCH64:
11502       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11503     case EM_ALPHA:
11504       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11505     case EM_IA_64:
11506       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11507     case EM_PARISC:
11508       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11509     case EM_PPC64:
11510       return reloc_type == 44; /* R_PPC64_REL64.  */
11511     case EM_SPARC32PLUS:
11512     case EM_SPARCV9:
11513     case EM_SPARC:
11514       return reloc_type == 46; /* R_SPARC_DISP64.  */
11515     case EM_X86_64:
11516     case EM_L1OM:
11517     case EM_K1OM:
11518       return reloc_type == 24; /* R_X86_64_PC64.  */
11519     case EM_S390_OLD:
11520     case EM_S390:
11521       return reloc_type == 23;  /* R_S390_PC64.  */
11522     case EM_TILEGX:
11523       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11524     default:
11525       return FALSE;
11526     }
11527 }
11528
11529 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11530    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11531
11532 static bfd_boolean
11533 is_24bit_abs_reloc (unsigned int reloc_type)
11534 {
11535   switch (elf_header.e_machine)
11536     {
11537     case EM_CYGNUS_MN10200:
11538     case EM_MN10200:
11539       return reloc_type == 4; /* R_MN10200_24.  */
11540     default:
11541       return FALSE;
11542     }
11543 }
11544
11545 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11546    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11547
11548 static bfd_boolean
11549 is_16bit_abs_reloc (unsigned int reloc_type)
11550 {
11551   switch (elf_header.e_machine)
11552     {
11553     case EM_AVR_OLD:
11554     case EM_AVR:
11555       return reloc_type == 4; /* R_AVR_16.  */
11556     case EM_ADAPTEVA_EPIPHANY:
11557       return reloc_type == 5;
11558     case EM_CYGNUS_D10V:
11559     case EM_D10V:
11560       return reloc_type == 3; /* R_D10V_16.  */
11561     case EM_H8S:
11562     case EM_H8_300:
11563     case EM_H8_300H:
11564       return reloc_type == R_H8_DIR16;
11565     case EM_IP2K_OLD:
11566     case EM_IP2K:
11567       return reloc_type == 1; /* R_IP2K_16.  */
11568     case EM_M32C_OLD:
11569     case EM_M32C:
11570       return reloc_type == 1; /* R_M32C_16 */
11571     case EM_MSP430:
11572       if (uses_msp430x_relocs ())
11573         return reloc_type == 2; /* R_MSP430_ABS16.  */
11574     case EM_MSP430_OLD:
11575       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11576     case EM_NDS32:
11577       return reloc_type == 19; /* R_NDS32_RELA.  */
11578     case EM_ALTERA_NIOS2:
11579       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11580     case EM_NIOS32:
11581       return reloc_type == 9; /* R_NIOS_16.  */
11582     case EM_OR1K:
11583       return reloc_type == 2; /* R_OR1K_16.  */
11584     case EM_TI_C6000:
11585       return reloc_type == 2; /* R_C6000_ABS16.  */
11586     case EM_XC16X:
11587     case EM_C166:
11588       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11589     case EM_CYGNUS_MN10200:
11590     case EM_MN10200:
11591       return reloc_type == 2; /* R_MN10200_16.  */
11592     case EM_CYGNUS_MN10300:
11593     case EM_MN10300:
11594       return reloc_type == 2; /* R_MN10300_16.  */
11595     case EM_VISIUM:
11596       return reloc_type == 2; /* R_VISIUM_16. */
11597     case EM_XGATE:
11598       return reloc_type == 3; /* R_XGATE_16.  */
11599     default:
11600       return FALSE;
11601     }
11602 }
11603
11604 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11605    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11606
11607 static bfd_boolean
11608 is_none_reloc (unsigned int reloc_type)
11609 {
11610   switch (elf_header.e_machine)
11611     {
11612     case EM_68K:     /* R_68K_NONE.  */
11613     case EM_386:     /* R_386_NONE.  */
11614     case EM_SPARC32PLUS:
11615     case EM_SPARCV9:
11616     case EM_SPARC:   /* R_SPARC_NONE.  */
11617     case EM_MIPS:    /* R_MIPS_NONE.  */
11618     case EM_PARISC:  /* R_PARISC_NONE.  */
11619     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11620     case EM_ADAPTEVA_EPIPHANY:
11621     case EM_PPC:     /* R_PPC_NONE.  */
11622     case EM_PPC64:   /* R_PPC64_NONE.  */
11623     case EM_ARM:     /* R_ARM_NONE.  */
11624     case EM_IA_64:   /* R_IA64_NONE.  */
11625     case EM_SH:      /* R_SH_NONE.  */
11626     case EM_S390_OLD:
11627     case EM_S390:    /* R_390_NONE.  */
11628     case EM_CRIS:    /* R_CRIS_NONE.  */
11629     case EM_X86_64:  /* R_X86_64_NONE.  */
11630     case EM_L1OM:    /* R_X86_64_NONE.  */
11631     case EM_K1OM:    /* R_X86_64_NONE.  */
11632     case EM_MN10300: /* R_MN10300_NONE.  */
11633     case EM_FT32:    /* R_FT32_NONE.  */
11634     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11635     case EM_M32R:    /* R_M32R_NONE.  */
11636     case EM_TI_C6000:/* R_C6000_NONE.  */
11637     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11638     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11639     case EM_XC16X:
11640     case EM_C166:    /* R_XC16X_NONE.  */
11641     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11642     case EM_NIOS32:  /* R_NIOS_NONE.  */
11643     case EM_OR1K:    /* R_OR1K_NONE. */
11644       return reloc_type == 0;
11645     case EM_AARCH64:
11646       return reloc_type == 0 || reloc_type == 256;
11647     case EM_NDS32:
11648       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11649               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11650               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11651               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11652               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11653     case EM_XTENSA_OLD:
11654     case EM_XTENSA:
11655       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11656               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11657               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11658               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11659     case EM_METAG:
11660       return reloc_type == 3; /* R_METAG_NONE.  */
11661     }
11662   return FALSE;
11663 }
11664
11665 /* Apply relocations to a section.
11666    Note: So far support has been added only for those relocations
11667    which can be found in debug sections.
11668    FIXME: Add support for more relocations ?  */
11669
11670 static void
11671 apply_relocations (void * file,
11672                    const Elf_Internal_Shdr * section,
11673                    unsigned char * start, bfd_size_type size)
11674 {
11675   Elf_Internal_Shdr * relsec;
11676   unsigned char * end = start + size;
11677
11678   if (elf_header.e_type != ET_REL)
11679     return;
11680
11681   /* Find the reloc section associated with the section.  */
11682   for (relsec = section_headers;
11683        relsec < section_headers + elf_header.e_shnum;
11684        ++relsec)
11685     {
11686       bfd_boolean is_rela;
11687       unsigned long num_relocs;
11688       Elf_Internal_Rela * relocs;
11689       Elf_Internal_Rela * rp;
11690       Elf_Internal_Shdr * symsec;
11691       Elf_Internal_Sym * symtab;
11692       unsigned long num_syms;
11693       Elf_Internal_Sym * sym;
11694
11695       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11696           || relsec->sh_info >= elf_header.e_shnum
11697           || section_headers + relsec->sh_info != section
11698           || relsec->sh_size == 0
11699           || relsec->sh_link >= elf_header.e_shnum)
11700         continue;
11701
11702       is_rela = relsec->sh_type == SHT_RELA;
11703
11704       if (is_rela)
11705         {
11706           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11707                                   relsec->sh_size, & relocs, & num_relocs))
11708             return;
11709         }
11710       else
11711         {
11712           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11713                                  relsec->sh_size, & relocs, & num_relocs))
11714             return;
11715         }
11716
11717       /* SH uses RELA but uses in place value instead of the addend field.  */
11718       if (elf_header.e_machine == EM_SH)
11719         is_rela = FALSE;
11720
11721       symsec = section_headers + relsec->sh_link;
11722       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11723
11724       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11725         {
11726           bfd_vma         addend;
11727           unsigned int    reloc_type;
11728           unsigned int    reloc_size;
11729           unsigned char * rloc;
11730           unsigned long   sym_index;
11731
11732           reloc_type = get_reloc_type (rp->r_info);
11733
11734           if (target_specific_reloc_handling (rp, start, symtab))
11735             continue;
11736           else if (is_none_reloc (reloc_type))
11737             continue;
11738           else if (is_32bit_abs_reloc (reloc_type)
11739                    || is_32bit_pcrel_reloc (reloc_type))
11740             reloc_size = 4;
11741           else if (is_64bit_abs_reloc (reloc_type)
11742                    || is_64bit_pcrel_reloc (reloc_type))
11743             reloc_size = 8;
11744           else if (is_24bit_abs_reloc (reloc_type))
11745             reloc_size = 3;
11746           else if (is_16bit_abs_reloc (reloc_type))
11747             reloc_size = 2;
11748           else
11749             {
11750               static unsigned int prev_reloc = 0;
11751               if (reloc_type != prev_reloc)
11752                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11753                       reloc_type, printable_section_name (section));
11754               prev_reloc = reloc_type;
11755               continue;
11756             }
11757
11758           rloc = start + rp->r_offset;
11759           if ((rloc + reloc_size) > end || (rloc < start))
11760             {
11761               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11762                     (unsigned long) rp->r_offset,
11763                     printable_section_name (section));
11764               continue;
11765             }
11766
11767           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11768           if (sym_index >= num_syms)
11769             {
11770               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11771                     sym_index, printable_section_name (section));
11772               continue;
11773             }
11774           sym = symtab + sym_index;
11775
11776           /* If the reloc has a symbol associated with it,
11777              make sure that it is of an appropriate type.
11778
11779              Relocations against symbols without type can happen.
11780              Gcc -feliminate-dwarf2-dups may generate symbols
11781              without type for debug info.
11782
11783              Icc generates relocations against function symbols
11784              instead of local labels.
11785
11786              Relocations against object symbols can happen, eg when
11787              referencing a global array.  For an example of this see
11788              the _clz.o binary in libgcc.a.  */
11789           if (sym != symtab
11790               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11791             {
11792               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11793                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11794                     (long int)(rp - relocs),
11795                     printable_section_name (relsec));
11796               continue;
11797             }
11798
11799           addend = 0;
11800           if (is_rela)
11801             addend += rp->r_addend;
11802           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11803              partial_inplace.  */
11804           if (!is_rela
11805               || (elf_header.e_machine == EM_XTENSA
11806                   && reloc_type == 1)
11807               || ((elf_header.e_machine == EM_PJ
11808                    || elf_header.e_machine == EM_PJ_OLD)
11809                   && reloc_type == 1)
11810               || ((elf_header.e_machine == EM_D30V
11811                    || elf_header.e_machine == EM_CYGNUS_D30V)
11812                   && reloc_type == 12))
11813             addend += byte_get (rloc, reloc_size);
11814
11815           if (is_32bit_pcrel_reloc (reloc_type)
11816               || is_64bit_pcrel_reloc (reloc_type))
11817             {
11818               /* On HPPA, all pc-relative relocations are biased by 8.  */
11819               if (elf_header.e_machine == EM_PARISC)
11820                 addend -= 8;
11821               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11822                         reloc_size);
11823             }
11824           else
11825             byte_put (rloc, addend + sym->st_value, reloc_size);
11826         }
11827
11828       free (symtab);
11829       free (relocs);
11830       break;
11831     }
11832 }
11833
11834 #ifdef SUPPORT_DISASSEMBLY
11835 static int
11836 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11837 {
11838   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11839
11840   /* FIXME: XXX -- to be done --- XXX */
11841
11842   return 1;
11843 }
11844 #endif
11845
11846 /* Reads in the contents of SECTION from FILE, returning a pointer
11847    to a malloc'ed buffer or NULL if something went wrong.  */
11848
11849 static char *
11850 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11851 {
11852   bfd_size_type num_bytes;
11853
11854   num_bytes = section->sh_size;
11855
11856   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11857     {
11858       printf (_("\nSection '%s' has no data to dump.\n"),
11859               printable_section_name (section));
11860       return NULL;
11861     }
11862
11863   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11864                              _("section contents"));
11865 }
11866
11867
11868 static void
11869 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11870 {
11871   Elf_Internal_Shdr * relsec;
11872   bfd_size_type num_bytes;
11873   char * data;
11874   char * end;
11875   char * start;
11876   bfd_boolean some_strings_shown;
11877
11878   start = get_section_contents (section, file);
11879   if (start == NULL)
11880     return;
11881
11882   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11883
11884   /* If the section being dumped has relocations against it the user might
11885      be expecting these relocations to have been applied.  Check for this
11886      case and issue a warning message in order to avoid confusion.
11887      FIXME: Maybe we ought to have an option that dumps a section with
11888      relocs applied ?  */
11889   for (relsec = section_headers;
11890        relsec < section_headers + elf_header.e_shnum;
11891        ++relsec)
11892     {
11893       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11894           || relsec->sh_info >= elf_header.e_shnum
11895           || section_headers + relsec->sh_info != section
11896           || relsec->sh_size == 0
11897           || relsec->sh_link >= elf_header.e_shnum)
11898         continue;
11899
11900       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11901       break;
11902     }
11903
11904   num_bytes = section->sh_size;
11905   data = start;
11906   end  = start + num_bytes;
11907   some_strings_shown = FALSE;
11908
11909   while (data < end)
11910     {
11911       while (!ISPRINT (* data))
11912         if (++ data >= end)
11913           break;
11914
11915       if (data < end)
11916         {
11917           size_t maxlen = end - data;
11918
11919 #ifndef __MSVCRT__
11920           /* PR 11128: Use two separate invocations in order to work
11921              around bugs in the Solaris 8 implementation of printf.  */
11922           printf ("  [%6tx]  ", data - start);
11923 #else
11924           printf ("  [%6Ix]  ", (size_t) (data - start));
11925 #endif
11926           if (maxlen > 0)
11927             {
11928               print_symbol ((int) maxlen, data);
11929               putchar ('\n');
11930               data += strnlen (data, maxlen);
11931             }
11932           else
11933             {
11934               printf (_("<corrupt>\n"));
11935               data = end;
11936             }
11937           some_strings_shown = TRUE;
11938         }
11939     }
11940
11941   if (! some_strings_shown)
11942     printf (_("  No strings found in this section."));
11943
11944   free (start);
11945
11946   putchar ('\n');
11947 }
11948
11949 static void
11950 dump_section_as_bytes (Elf_Internal_Shdr * section,
11951                        FILE * file,
11952                        bfd_boolean relocate)
11953 {
11954   Elf_Internal_Shdr * relsec;
11955   bfd_size_type bytes;
11956   bfd_vma addr;
11957   unsigned char * data;
11958   unsigned char * start;
11959
11960   start = (unsigned char *) get_section_contents (section, file);
11961   if (start == NULL)
11962     return;
11963
11964   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11965
11966   if (relocate)
11967     {
11968       apply_relocations (file, section, start, section->sh_size);
11969     }
11970   else
11971     {
11972       /* If the section being dumped has relocations against it the user might
11973          be expecting these relocations to have been applied.  Check for this
11974          case and issue a warning message in order to avoid confusion.
11975          FIXME: Maybe we ought to have an option that dumps a section with
11976          relocs applied ?  */
11977       for (relsec = section_headers;
11978            relsec < section_headers + elf_header.e_shnum;
11979            ++relsec)
11980         {
11981           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11982               || relsec->sh_info >= elf_header.e_shnum
11983               || section_headers + relsec->sh_info != section
11984               || relsec->sh_size == 0
11985               || relsec->sh_link >= elf_header.e_shnum)
11986             continue;
11987
11988           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11989           break;
11990         }
11991     }
11992
11993   addr = section->sh_addr;
11994   bytes = section->sh_size;
11995   data = start;
11996
11997   while (bytes)
11998     {
11999       int j;
12000       int k;
12001       int lbytes;
12002
12003       lbytes = (bytes > 16 ? 16 : bytes);
12004
12005       printf ("  0x%8.8lx ", (unsigned long) addr);
12006
12007       for (j = 0; j < 16; j++)
12008         {
12009           if (j < lbytes)
12010             printf ("%2.2x", data[j]);
12011           else
12012             printf ("  ");
12013
12014           if ((j & 3) == 3)
12015             printf (" ");
12016         }
12017
12018       for (j = 0; j < lbytes; j++)
12019         {
12020           k = data[j];
12021           if (k >= ' ' && k < 0x7f)
12022             printf ("%c", k);
12023           else
12024             printf (".");
12025         }
12026
12027       putchar ('\n');
12028
12029       data  += lbytes;
12030       addr  += lbytes;
12031       bytes -= lbytes;
12032     }
12033
12034   free (start);
12035
12036   putchar ('\n');
12037 }
12038
12039 /* Uncompresses a section that was compressed using zlib, in place.  */
12040
12041 static int
12042 uncompress_section_contents (unsigned char **buffer,
12043                              dwarf_size_type *size)
12044 {
12045   dwarf_size_type compressed_size = *size;
12046   unsigned char * compressed_buffer = *buffer;
12047   dwarf_size_type uncompressed_size;
12048   unsigned char * uncompressed_buffer;
12049   z_stream strm;
12050   int rc;
12051   dwarf_size_type header_size = 12;
12052
12053   /* Read the zlib header.  In this case, it should be "ZLIB" followed
12054      by the uncompressed section size, 8 bytes in big-endian order.  */
12055   if (compressed_size < header_size
12056       || ! streq ((char *) compressed_buffer, "ZLIB"))
12057     return 0;
12058
12059   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
12060   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
12061   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
12062   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
12063   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
12064   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
12065   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
12066   uncompressed_size += compressed_buffer[11];
12067
12068   /* It is possible the section consists of several compressed
12069      buffers concatenated together, so we uncompress in a loop.  */
12070   /* PR 18313: The state field in the z_stream structure is supposed
12071      to be invisible to the user (ie us), but some compilers will
12072      still complain about it being used without initialisation.  So
12073      we first zero the entire z_stream structure and then set the fields
12074      that we need.  */
12075   memset (& strm, 0, sizeof strm);
12076   strm.avail_in = compressed_size - header_size;
12077   strm.next_in = (Bytef *) compressed_buffer + header_size;
12078   strm.avail_out = uncompressed_size;
12079   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12080
12081   rc = inflateInit (& strm);
12082   while (strm.avail_in > 0)
12083     {
12084       if (rc != Z_OK)
12085         goto fail;
12086       strm.next_out = ((Bytef *) uncompressed_buffer
12087                        + (uncompressed_size - strm.avail_out));
12088       rc = inflate (&strm, Z_FINISH);
12089       if (rc != Z_STREAM_END)
12090         goto fail;
12091       rc = inflateReset (& strm);
12092     }
12093   rc = inflateEnd (& strm);
12094   if (rc != Z_OK
12095       || strm.avail_out != 0)
12096     goto fail;
12097
12098   *buffer = uncompressed_buffer;
12099   *size = uncompressed_size;
12100   return 1;
12101
12102  fail:
12103   free (uncompressed_buffer);
12104   /* Indicate decompression failure.  */
12105   *buffer = NULL;
12106   return 0;
12107 }
12108
12109 static int
12110 load_specific_debug_section (enum dwarf_section_display_enum debug,
12111                              const Elf_Internal_Shdr * sec, void * file)
12112 {
12113   struct dwarf_section * section = &debug_displays [debug].section;
12114   char buf [64];
12115
12116   /* If it is already loaded, do nothing.  */
12117   if (section->start != NULL)
12118     return 1;
12119
12120   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12121   section->address = sec->sh_addr;
12122   section->user_data = NULL;
12123   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12124                                                sec->sh_offset, 1,
12125                                                sec->sh_size, buf);
12126   if (section->start == NULL)
12127     section->size = 0;
12128   else
12129     {
12130       unsigned char *start = section->start;
12131       dwarf_size_type size = sec->sh_size;
12132
12133       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12134         {
12135           Elf_Internal_Chdr chdr;
12136           unsigned int compression_header_size
12137             = get_compression_header (&chdr, start);
12138           if (chdr.ch_type != ELFCOMPRESS_ZLIB
12139               || chdr.ch_addralign != sec->sh_addralign)
12140             return 0;
12141           start += compression_header_size;
12142           size -= compression_header_size;
12143         }
12144
12145       if (uncompress_section_contents (&start, &size))
12146         {
12147           /* Free the compressed buffer, update the section buffer
12148              and the section size if uncompress is successful.  */
12149           free (section->start);
12150           section->start = start;
12151         }
12152       section->size = size;
12153     }
12154
12155   if (section->start == NULL)
12156     return 0;
12157
12158   if (debug_displays [debug].relocate)
12159     apply_relocations ((FILE *) file, sec, section->start, section->size);
12160
12161   return 1;
12162 }
12163
12164 /* If this is not NULL, load_debug_section will only look for sections
12165    within the list of sections given here.  */
12166 unsigned int *section_subset = NULL;
12167
12168 int
12169 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12170 {
12171   struct dwarf_section * section = &debug_displays [debug].section;
12172   Elf_Internal_Shdr * sec;
12173
12174   /* Locate the debug section.  */
12175   sec = find_section_in_set (section->uncompressed_name, section_subset);
12176   if (sec != NULL)
12177     section->name = section->uncompressed_name;
12178   else
12179     {
12180       sec = find_section_in_set (section->compressed_name, section_subset);
12181       if (sec != NULL)
12182         section->name = section->compressed_name;
12183     }
12184   if (sec == NULL)
12185     return 0;
12186
12187   /* If we're loading from a subset of sections, and we've loaded
12188      a section matching this name before, it's likely that it's a
12189      different one.  */
12190   if (section_subset != NULL)
12191     free_debug_section (debug);
12192
12193   return load_specific_debug_section (debug, sec, (FILE *) file);
12194 }
12195
12196 void
12197 free_debug_section (enum dwarf_section_display_enum debug)
12198 {
12199   struct dwarf_section * section = &debug_displays [debug].section;
12200
12201   if (section->start == NULL)
12202     return;
12203
12204   free ((char *) section->start);
12205   section->start = NULL;
12206   section->address = 0;
12207   section->size = 0;
12208 }
12209
12210 static int
12211 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12212 {
12213   char * name = SECTION_NAME (section);
12214   const char * print_name = printable_section_name (section);
12215   bfd_size_type length;
12216   int result = 1;
12217   int i;
12218
12219   length = section->sh_size;
12220   if (length == 0)
12221     {
12222       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12223       return 0;
12224     }
12225   if (section->sh_type == SHT_NOBITS)
12226     {
12227       /* There is no point in dumping the contents of a debugging section
12228          which has the NOBITS type - the bits in the file will be random.
12229          This can happen when a file containing a .eh_frame section is
12230          stripped with the --only-keep-debug command line option.  */
12231       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12232               print_name);
12233       return 0;
12234     }
12235
12236   if (const_strneq (name, ".gnu.linkonce.wi."))
12237     name = ".debug_info";
12238
12239   /* See if we know how to display the contents of this section.  */
12240   for (i = 0; i < max; i++)
12241     if (streq (debug_displays[i].section.uncompressed_name, name)
12242         || (i == line && const_strneq (name, ".debug_line."))
12243         || streq (debug_displays[i].section.compressed_name, name))
12244       {
12245         struct dwarf_section * sec = &debug_displays [i].section;
12246         int secondary = (section != find_section (name));
12247
12248         if (secondary)
12249           free_debug_section ((enum dwarf_section_display_enum) i);
12250
12251         if (i == line && const_strneq (name, ".debug_line."))
12252           sec->name = name;
12253         else if (streq (sec->uncompressed_name, name))
12254           sec->name = sec->uncompressed_name;
12255         else
12256           sec->name = sec->compressed_name;
12257         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12258                                          section, file))
12259           {
12260             /* If this debug section is part of a CU/TU set in a .dwp file,
12261                restrict load_debug_section to the sections in that set.  */
12262             section_subset = find_cu_tu_set (file, shndx);
12263
12264             result &= debug_displays[i].display (sec, file);
12265
12266             section_subset = NULL;
12267
12268             if (secondary || (i != info && i != abbrev))
12269               free_debug_section ((enum dwarf_section_display_enum) i);
12270           }
12271
12272         break;
12273       }
12274
12275   if (i == max)
12276     {
12277       printf (_("Unrecognized debug section: %s\n"), print_name);
12278       result = 0;
12279     }
12280
12281   return result;
12282 }
12283
12284 /* Set DUMP_SECTS for all sections where dumps were requested
12285    based on section name.  */
12286
12287 static void
12288 initialise_dumps_byname (void)
12289 {
12290   struct dump_list_entry * cur;
12291
12292   for (cur = dump_sects_byname; cur; cur = cur->next)
12293     {
12294       unsigned int i;
12295       int any;
12296
12297       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12298         if (streq (SECTION_NAME (section_headers + i), cur->name))
12299           {
12300             request_dump_bynumber (i, cur->type);
12301             any = 1;
12302           }
12303
12304       if (!any)
12305         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12306               cur->name);
12307     }
12308 }
12309
12310 static void
12311 process_section_contents (FILE * file)
12312 {
12313   Elf_Internal_Shdr * section;
12314   unsigned int i;
12315
12316   if (! do_dump)
12317     return;
12318
12319   initialise_dumps_byname ();
12320
12321   for (i = 0, section = section_headers;
12322        i < elf_header.e_shnum && i < num_dump_sects;
12323        i++, section++)
12324     {
12325 #ifdef SUPPORT_DISASSEMBLY
12326       if (dump_sects[i] & DISASS_DUMP)
12327         disassemble_section (section, file);
12328 #endif
12329       if (dump_sects[i] & HEX_DUMP)
12330         dump_section_as_bytes (section, file, FALSE);
12331
12332       if (dump_sects[i] & RELOC_DUMP)
12333         dump_section_as_bytes (section, file, TRUE);
12334
12335       if (dump_sects[i] & STRING_DUMP)
12336         dump_section_as_strings (section, file);
12337
12338       if (dump_sects[i] & DEBUG_DUMP)
12339         display_debug_section (i, section, file);
12340     }
12341
12342   /* Check to see if the user requested a
12343      dump of a section that does not exist.  */
12344   while (i++ < num_dump_sects)
12345     if (dump_sects[i])
12346       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12347 }
12348
12349 static void
12350 process_mips_fpe_exception (int mask)
12351 {
12352   if (mask)
12353     {
12354       int first = 1;
12355       if (mask & OEX_FPU_INEX)
12356         fputs ("INEX", stdout), first = 0;
12357       if (mask & OEX_FPU_UFLO)
12358         printf ("%sUFLO", first ? "" : "|"), first = 0;
12359       if (mask & OEX_FPU_OFLO)
12360         printf ("%sOFLO", first ? "" : "|"), first = 0;
12361       if (mask & OEX_FPU_DIV0)
12362         printf ("%sDIV0", first ? "" : "|"), first = 0;
12363       if (mask & OEX_FPU_INVAL)
12364         printf ("%sINVAL", first ? "" : "|");
12365     }
12366   else
12367     fputs ("0", stdout);
12368 }
12369
12370 /* Display's the value of TAG at location P.  If TAG is
12371    greater than 0 it is assumed to be an unknown tag, and
12372    a message is printed to this effect.  Otherwise it is
12373    assumed that a message has already been printed.
12374
12375    If the bottom bit of TAG is set it assumed to have a
12376    string value, otherwise it is assumed to have an integer
12377    value.
12378
12379    Returns an updated P pointing to the first unread byte
12380    beyond the end of TAG's value.
12381
12382    Reads at or beyond END will not be made.  */
12383
12384 static unsigned char *
12385 display_tag_value (int tag,
12386                    unsigned char * p,
12387                    const unsigned char * const end)
12388 {
12389   unsigned long val;
12390
12391   if (tag > 0)
12392     printf ("  Tag_unknown_%d: ", tag);
12393
12394   if (p >= end)
12395     {
12396       warn (_("<corrupt tag>\n"));
12397     }
12398   else if (tag & 1)
12399     {
12400       /* PR 17531 file: 027-19978-0.004.  */
12401       size_t maxlen = (end - p) - 1;
12402
12403       putchar ('"');
12404       if (maxlen > 0)
12405         {
12406           print_symbol ((int) maxlen, (const char *) p);
12407           p += strnlen ((char *) p, maxlen) + 1;
12408         }
12409       else
12410         {
12411           printf (_("<corrupt string tag>"));
12412           p = (unsigned char *) end;
12413         }
12414       printf ("\"\n");
12415     }
12416   else
12417     {
12418       unsigned int len;
12419
12420       val = read_uleb128 (p, &len, end);
12421       p += len;
12422       printf ("%ld (0x%lx)\n", val, val);
12423     }
12424
12425   assert (p <= end);
12426   return p;
12427 }
12428
12429 /* ARM EABI attributes section.  */
12430 typedef struct
12431 {
12432   unsigned int tag;
12433   const char * name;
12434   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12435   unsigned int type;
12436   const char ** table;
12437 } arm_attr_public_tag;
12438
12439 static const char * arm_attr_tag_CPU_arch[] =
12440   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12441    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12442 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12443 static const char * arm_attr_tag_THUMB_ISA_use[] =
12444   {"No", "Thumb-1", "Thumb-2"};
12445 static const char * arm_attr_tag_FP_arch[] =
12446   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12447    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12448 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12449 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12450   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12451 static const char * arm_attr_tag_PCS_config[] =
12452   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12453    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12454 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12455   {"V6", "SB", "TLS", "Unused"};
12456 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12457   {"Absolute", "PC-relative", "SB-relative", "None"};
12458 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12459   {"Absolute", "PC-relative", "None"};
12460 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12461   {"None", "direct", "GOT-indirect"};
12462 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12463   {"None", "??? 1", "2", "??? 3", "4"};
12464 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12465 static const char * arm_attr_tag_ABI_FP_denormal[] =
12466   {"Unused", "Needed", "Sign only"};
12467 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12468 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12469 static const char * arm_attr_tag_ABI_FP_number_model[] =
12470   {"Unused", "Finite", "RTABI", "IEEE 754"};
12471 static const char * arm_attr_tag_ABI_enum_size[] =
12472   {"Unused", "small", "int", "forced to int"};
12473 static const char * arm_attr_tag_ABI_HardFP_use[] =
12474   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12475 static const char * arm_attr_tag_ABI_VFP_args[] =
12476   {"AAPCS", "VFP registers", "custom", "compatible"};
12477 static const char * arm_attr_tag_ABI_WMMX_args[] =
12478   {"AAPCS", "WMMX registers", "custom"};
12479 static const char * arm_attr_tag_ABI_optimization_goals[] =
12480   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12481     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12482 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12483   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12484     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12485 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12486 static const char * arm_attr_tag_FP_HP_extension[] =
12487   {"Not Allowed", "Allowed"};
12488 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12489   {"None", "IEEE 754", "Alternative Format"};
12490 static const char * arm_attr_tag_MPextension_use[] =
12491   {"Not Allowed", "Allowed"};
12492 static const char * arm_attr_tag_DIV_use[] =
12493   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12494     "Allowed in v7-A with integer division extension"};
12495 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12496 static const char * arm_attr_tag_Virtualization_use[] =
12497   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12498     "TrustZone and Virtualization Extensions"};
12499 static const char * arm_attr_tag_MPextension_use_legacy[] =
12500   {"Not Allowed", "Allowed"};
12501
12502 #define LOOKUP(id, name) \
12503   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12504 static arm_attr_public_tag arm_attr_public_tags[] =
12505 {
12506   {4, "CPU_raw_name", 1, NULL},
12507   {5, "CPU_name", 1, NULL},
12508   LOOKUP(6, CPU_arch),
12509   {7, "CPU_arch_profile", 0, NULL},
12510   LOOKUP(8, ARM_ISA_use),
12511   LOOKUP(9, THUMB_ISA_use),
12512   LOOKUP(10, FP_arch),
12513   LOOKUP(11, WMMX_arch),
12514   LOOKUP(12, Advanced_SIMD_arch),
12515   LOOKUP(13, PCS_config),
12516   LOOKUP(14, ABI_PCS_R9_use),
12517   LOOKUP(15, ABI_PCS_RW_data),
12518   LOOKUP(16, ABI_PCS_RO_data),
12519   LOOKUP(17, ABI_PCS_GOT_use),
12520   LOOKUP(18, ABI_PCS_wchar_t),
12521   LOOKUP(19, ABI_FP_rounding),
12522   LOOKUP(20, ABI_FP_denormal),
12523   LOOKUP(21, ABI_FP_exceptions),
12524   LOOKUP(22, ABI_FP_user_exceptions),
12525   LOOKUP(23, ABI_FP_number_model),
12526   {24, "ABI_align_needed", 0, NULL},
12527   {25, "ABI_align_preserved", 0, NULL},
12528   LOOKUP(26, ABI_enum_size),
12529   LOOKUP(27, ABI_HardFP_use),
12530   LOOKUP(28, ABI_VFP_args),
12531   LOOKUP(29, ABI_WMMX_args),
12532   LOOKUP(30, ABI_optimization_goals),
12533   LOOKUP(31, ABI_FP_optimization_goals),
12534   {32, "compatibility", 0, NULL},
12535   LOOKUP(34, CPU_unaligned_access),
12536   LOOKUP(36, FP_HP_extension),
12537   LOOKUP(38, ABI_FP_16bit_format),
12538   LOOKUP(42, MPextension_use),
12539   LOOKUP(44, DIV_use),
12540   {64, "nodefaults", 0, NULL},
12541   {65, "also_compatible_with", 0, NULL},
12542   LOOKUP(66, T2EE_use),
12543   {67, "conformance", 1, NULL},
12544   LOOKUP(68, Virtualization_use),
12545   LOOKUP(70, MPextension_use_legacy)
12546 };
12547 #undef LOOKUP
12548
12549 static unsigned char *
12550 display_arm_attribute (unsigned char * p,
12551                        const unsigned char * const end)
12552 {
12553   unsigned int tag;
12554   unsigned int len;
12555   unsigned int val;
12556   arm_attr_public_tag * attr;
12557   unsigned i;
12558   unsigned int type;
12559
12560   tag = read_uleb128 (p, &len, end);
12561   p += len;
12562   attr = NULL;
12563   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12564     {
12565       if (arm_attr_public_tags[i].tag == tag)
12566         {
12567           attr = &arm_attr_public_tags[i];
12568           break;
12569         }
12570     }
12571
12572   if (attr)
12573     {
12574       printf ("  Tag_%s: ", attr->name);
12575       switch (attr->type)
12576         {
12577         case 0:
12578           switch (tag)
12579             {
12580             case 7: /* Tag_CPU_arch_profile.  */
12581               val = read_uleb128 (p, &len, end);
12582               p += len;
12583               switch (val)
12584                 {
12585                 case 0: printf (_("None\n")); break;
12586                 case 'A': printf (_("Application\n")); break;
12587                 case 'R': printf (_("Realtime\n")); break;
12588                 case 'M': printf (_("Microcontroller\n")); break;
12589                 case 'S': printf (_("Application or Realtime\n")); break;
12590                 default: printf ("??? (%d)\n", val); break;
12591                 }
12592               break;
12593
12594             case 24: /* Tag_align_needed.  */
12595               val = read_uleb128 (p, &len, end);
12596               p += len;
12597               switch (val)
12598                 {
12599                 case 0: printf (_("None\n")); break;
12600                 case 1: printf (_("8-byte\n")); break;
12601                 case 2: printf (_("4-byte\n")); break;
12602                 case 3: printf ("??? 3\n"); break;
12603                 default:
12604                   if (val <= 12)
12605                     printf (_("8-byte and up to %d-byte extended\n"),
12606                             1 << val);
12607                   else
12608                     printf ("??? (%d)\n", val);
12609                   break;
12610                 }
12611               break;
12612
12613             case 25: /* Tag_align_preserved.  */
12614               val = read_uleb128 (p, &len, end);
12615               p += len;
12616               switch (val)
12617                 {
12618                 case 0: printf (_("None\n")); break;
12619                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12620                 case 2: printf (_("8-byte\n")); break;
12621                 case 3: printf ("??? 3\n"); break;
12622                 default:
12623                   if (val <= 12)
12624                     printf (_("8-byte and up to %d-byte extended\n"),
12625                             1 << val);
12626                   else
12627                     printf ("??? (%d)\n", val);
12628                   break;
12629                 }
12630               break;
12631
12632             case 32: /* Tag_compatibility.  */
12633               {
12634                 val = read_uleb128 (p, &len, end);
12635                 p += len;
12636                 printf (_("flag = %d, vendor = "), val);
12637                 if (p < end - 1)
12638                   {
12639                     size_t maxlen = (end - p) - 1;
12640
12641                     print_symbol ((int) maxlen, (const char *) p);
12642                     p += strnlen ((char *) p, maxlen) + 1;
12643                   }
12644                 else
12645                   {
12646                     printf (_("<corrupt>"));
12647                     p = (unsigned char *) end;
12648                   }
12649                 putchar ('\n');
12650               }
12651               break;
12652
12653             case 64: /* Tag_nodefaults.  */
12654               /* PR 17531: file: 001-505008-0.01.  */
12655               if (p < end)
12656                 p++;
12657               printf (_("True\n"));
12658               break;
12659
12660             case 65: /* Tag_also_compatible_with.  */
12661               val = read_uleb128 (p, &len, end);
12662               p += len;
12663               if (val == 6 /* Tag_CPU_arch.  */)
12664                 {
12665                   val = read_uleb128 (p, &len, end);
12666                   p += len;
12667                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12668                     printf ("??? (%d)\n", val);
12669                   else
12670                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12671                 }
12672               else
12673                 printf ("???\n");
12674               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12675                 ;
12676               break;
12677
12678             default:
12679               printf (_("<unknown: %d>\n"), tag);
12680               break;
12681             }
12682           return p;
12683
12684         case 1:
12685           return display_tag_value (-1, p, end);
12686         case 2:
12687           return display_tag_value (0, p, end);
12688
12689         default:
12690           assert (attr->type & 0x80);
12691           val = read_uleb128 (p, &len, end);
12692           p += len;
12693           type = attr->type & 0x7f;
12694           if (val >= type)
12695             printf ("??? (%d)\n", val);
12696           else
12697             printf ("%s\n", attr->table[val]);
12698           return p;
12699         }
12700     }
12701
12702   return display_tag_value (tag, p, end);
12703 }
12704
12705 static unsigned char *
12706 display_gnu_attribute (unsigned char * p,
12707                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12708                        const unsigned char * const end)
12709 {
12710   int tag;
12711   unsigned int len;
12712   int val;
12713
12714   tag = read_uleb128 (p, &len, end);
12715   p += len;
12716
12717   /* Tag_compatibility is the only generic GNU attribute defined at
12718      present.  */
12719   if (tag == 32)
12720     {
12721       val = read_uleb128 (p, &len, end);
12722       p += len;
12723
12724       printf (_("flag = %d, vendor = "), val);
12725       if (p == end)
12726         {
12727           printf (_("<corrupt>\n"));
12728           warn (_("corrupt vendor attribute\n"));
12729         }
12730       else
12731         {
12732           if (p < end - 1)
12733             {
12734               size_t maxlen = (end - p) - 1;
12735
12736               print_symbol ((int) maxlen, (const char *) p);
12737               p += strnlen ((char *) p, maxlen) + 1;
12738             }
12739           else
12740             {
12741               printf (_("<corrupt>"));
12742               p = (unsigned char *) end;
12743             }
12744           putchar ('\n');
12745         }
12746       return p;
12747     }
12748
12749   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12750     return display_proc_gnu_attribute (p, tag, end);
12751
12752   return display_tag_value (tag, p, end);
12753 }
12754
12755 static unsigned char *
12756 display_power_gnu_attribute (unsigned char * p,
12757                              int tag,
12758                              const unsigned char * const end)
12759 {
12760   unsigned int len;
12761   int val;
12762
12763   if (tag == Tag_GNU_Power_ABI_FP)
12764     {
12765       val = read_uleb128 (p, &len, end);
12766       p += len;
12767       printf ("  Tag_GNU_Power_ABI_FP: ");
12768
12769       switch (val)
12770         {
12771         case 0:
12772           printf (_("Hard or soft float\n"));
12773           break;
12774         case 1:
12775           printf (_("Hard float\n"));
12776           break;
12777         case 2:
12778           printf (_("Soft float\n"));
12779           break;
12780         case 3:
12781           printf (_("Single-precision hard float\n"));
12782           break;
12783         default:
12784           printf ("??? (%d)\n", val);
12785           break;
12786         }
12787       return p;
12788    }
12789
12790   if (tag == Tag_GNU_Power_ABI_Vector)
12791     {
12792       val = read_uleb128 (p, &len, end);
12793       p += len;
12794       printf ("  Tag_GNU_Power_ABI_Vector: ");
12795       switch (val)
12796         {
12797         case 0:
12798           printf (_("Any\n"));
12799           break;
12800         case 1:
12801           printf (_("Generic\n"));
12802           break;
12803         case 2:
12804           printf ("AltiVec\n");
12805           break;
12806         case 3:
12807           printf ("SPE\n");
12808           break;
12809         default:
12810           printf ("??? (%d)\n", val);
12811           break;
12812         }
12813       return p;
12814    }
12815
12816   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12817     {
12818       if (p == end)
12819         {
12820           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12821           return p;
12822         }
12823
12824       val = read_uleb128 (p, &len, end);
12825       p += len;
12826       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12827       switch (val)
12828        {
12829        case 0:
12830          printf (_("Any\n"));
12831          break;
12832        case 1:
12833          printf ("r3/r4\n");
12834          break;
12835        case 2:
12836          printf (_("Memory\n"));
12837          break;
12838        default:
12839          printf ("??? (%d)\n", val);
12840          break;
12841        }
12842       return p;
12843     }
12844
12845   return display_tag_value (tag & 1, p, end);
12846 }
12847
12848 static unsigned char *
12849 display_s390_gnu_attribute (unsigned char * p,
12850                             int tag,
12851                             const unsigned char * const end)
12852 {
12853   unsigned int len;
12854   int val;
12855
12856   if (tag == Tag_GNU_S390_ABI_Vector)
12857     {
12858       val = read_uleb128 (p, &len, end);
12859       p += len;
12860       printf ("  Tag_GNU_S390_ABI_Vector: ");
12861
12862       switch (val)
12863         {
12864         case 0:
12865           printf (_("any\n"));
12866           break;
12867         case 1:
12868           printf (_("software\n"));
12869           break;
12870         case 2:
12871           printf (_("hardware\n"));
12872           break;
12873         default:
12874           printf ("??? (%d)\n", val);
12875           break;
12876         }
12877       return p;
12878    }
12879
12880   return display_tag_value (tag & 1, p, end);
12881 }
12882
12883 static void
12884 display_sparc_hwcaps (int mask)
12885 {
12886   if (mask)
12887     {
12888       int first = 1;
12889
12890       if (mask & ELF_SPARC_HWCAP_MUL32)
12891         fputs ("mul32", stdout), first = 0;
12892       if (mask & ELF_SPARC_HWCAP_DIV32)
12893         printf ("%sdiv32", first ? "" : "|"), first = 0;
12894       if (mask & ELF_SPARC_HWCAP_FSMULD)
12895         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12896       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12897         printf ("%sv8plus", first ? "" : "|"), first = 0;
12898       if (mask & ELF_SPARC_HWCAP_POPC)
12899         printf ("%spopc", first ? "" : "|"), first = 0;
12900       if (mask & ELF_SPARC_HWCAP_VIS)
12901         printf ("%svis", first ? "" : "|"), first = 0;
12902       if (mask & ELF_SPARC_HWCAP_VIS2)
12903         printf ("%svis2", first ? "" : "|"), first = 0;
12904       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12905         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12906       if (mask & ELF_SPARC_HWCAP_FMAF)
12907         printf ("%sfmaf", first ? "" : "|"), first = 0;
12908       if (mask & ELF_SPARC_HWCAP_VIS3)
12909         printf ("%svis3", first ? "" : "|"), first = 0;
12910       if (mask & ELF_SPARC_HWCAP_HPC)
12911         printf ("%shpc", first ? "" : "|"), first = 0;
12912       if (mask & ELF_SPARC_HWCAP_RANDOM)
12913         printf ("%srandom", first ? "" : "|"), first = 0;
12914       if (mask & ELF_SPARC_HWCAP_TRANS)
12915         printf ("%strans", first ? "" : "|"), first = 0;
12916       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12917         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12918       if (mask & ELF_SPARC_HWCAP_IMA)
12919         printf ("%sima", first ? "" : "|"), first = 0;
12920       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12921         printf ("%scspare", first ? "" : "|"), first = 0;
12922     }
12923   else
12924     fputc ('0', stdout);
12925   fputc ('\n', stdout);
12926 }
12927
12928 static void
12929 display_sparc_hwcaps2 (int mask)
12930 {
12931   if (mask)
12932     {
12933       int first = 1;
12934
12935       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12936         fputs ("fjathplus", stdout), first = 0;
12937       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12938         printf ("%svis3b", first ? "" : "|"), first = 0;
12939       if (mask & ELF_SPARC_HWCAP2_ADP)
12940         printf ("%sadp", first ? "" : "|"), first = 0;
12941       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12942         printf ("%ssparc5", first ? "" : "|"), first = 0;
12943       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12944         printf ("%smwait", first ? "" : "|"), first = 0;
12945       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12946         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12947       if (mask & ELF_SPARC_HWCAP2_XMONT)
12948         printf ("%sxmont2", first ? "" : "|"), first = 0;
12949       if (mask & ELF_SPARC_HWCAP2_NSEC)
12950         printf ("%snsec", first ? "" : "|"), first = 0;
12951       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12952         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12953       if (mask & ELF_SPARC_HWCAP2_FJDES)
12954         printf ("%sfjdes", first ? "" : "|"), first = 0;
12955       if (mask & ELF_SPARC_HWCAP2_FJAES)
12956         printf ("%sfjaes", first ? "" : "|"), first = 0;
12957     }
12958   else
12959     fputc ('0', stdout);
12960   fputc ('\n', stdout);
12961 }
12962
12963 static unsigned char *
12964 display_sparc_gnu_attribute (unsigned char * p,
12965                              int tag,
12966                              const unsigned char * const end)
12967 {
12968   unsigned int len;
12969   int val;
12970
12971   if (tag == Tag_GNU_Sparc_HWCAPS)
12972     {
12973       val = read_uleb128 (p, &len, end);
12974       p += len;
12975       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12976       display_sparc_hwcaps (val);
12977       return p;
12978     }
12979   if (tag == Tag_GNU_Sparc_HWCAPS2)
12980     {
12981       val = read_uleb128 (p, &len, end);
12982       p += len;
12983       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12984       display_sparc_hwcaps2 (val);
12985       return p;
12986     }
12987
12988   return display_tag_value (tag, p, end);
12989 }
12990
12991 static void
12992 print_mips_fp_abi_value (int val)
12993 {
12994   switch (val)
12995     {
12996     case Val_GNU_MIPS_ABI_FP_ANY:
12997       printf (_("Hard or soft float\n"));
12998       break;
12999     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13000       printf (_("Hard float (double precision)\n"));
13001       break;
13002     case Val_GNU_MIPS_ABI_FP_SINGLE:
13003       printf (_("Hard float (single precision)\n"));
13004       break;
13005     case Val_GNU_MIPS_ABI_FP_SOFT:
13006       printf (_("Soft float\n"));
13007       break;
13008     case Val_GNU_MIPS_ABI_FP_OLD_64:
13009       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13010       break;
13011     case Val_GNU_MIPS_ABI_FP_XX:
13012       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13013       break;
13014     case Val_GNU_MIPS_ABI_FP_64:
13015       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13016       break;
13017     case Val_GNU_MIPS_ABI_FP_64A:
13018       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13019       break;
13020     default:
13021       printf ("??? (%d)\n", val);
13022       break;
13023     }
13024 }
13025
13026 static unsigned char *
13027 display_mips_gnu_attribute (unsigned char * p,
13028                             int tag,
13029                             const unsigned char * const end)
13030 {
13031   if (tag == Tag_GNU_MIPS_ABI_FP)
13032     {
13033       unsigned int len;
13034       int val;
13035
13036       val = read_uleb128 (p, &len, end);
13037       p += len;
13038       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13039
13040       print_mips_fp_abi_value (val);
13041
13042       return p;
13043    }
13044
13045   if (tag == Tag_GNU_MIPS_ABI_MSA)
13046     {
13047       unsigned int len;
13048       int val;
13049
13050       val = read_uleb128 (p, &len, end);
13051       p += len;
13052       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13053
13054       switch (val)
13055         {
13056         case Val_GNU_MIPS_ABI_MSA_ANY:
13057           printf (_("Any MSA or not\n"));
13058           break;
13059         case Val_GNU_MIPS_ABI_MSA_128:
13060           printf (_("128-bit MSA\n"));
13061           break;
13062         default:
13063           printf ("??? (%d)\n", val);
13064           break;
13065         }
13066       return p;
13067     }
13068
13069   return display_tag_value (tag & 1, p, end);
13070 }
13071
13072 static unsigned char *
13073 display_tic6x_attribute (unsigned char * p,
13074                          const unsigned char * const end)
13075 {
13076   int tag;
13077   unsigned int len;
13078   int val;
13079
13080   tag = read_uleb128 (p, &len, end);
13081   p += len;
13082
13083   switch (tag)
13084     {
13085     case Tag_ISA:
13086       val = read_uleb128 (p, &len, end);
13087       p += len;
13088       printf ("  Tag_ISA: ");
13089
13090       switch (val)
13091         {
13092         case C6XABI_Tag_ISA_none:
13093           printf (_("None\n"));
13094           break;
13095         case C6XABI_Tag_ISA_C62X:
13096           printf ("C62x\n");
13097           break;
13098         case C6XABI_Tag_ISA_C67X:
13099           printf ("C67x\n");
13100           break;
13101         case C6XABI_Tag_ISA_C67XP:
13102           printf ("C67x+\n");
13103           break;
13104         case C6XABI_Tag_ISA_C64X:
13105           printf ("C64x\n");
13106           break;
13107         case C6XABI_Tag_ISA_C64XP:
13108           printf ("C64x+\n");
13109           break;
13110         case C6XABI_Tag_ISA_C674X:
13111           printf ("C674x\n");
13112           break;
13113         default:
13114           printf ("??? (%d)\n", val);
13115           break;
13116         }
13117       return p;
13118
13119     case Tag_ABI_wchar_t:
13120       val = read_uleb128 (p, &len, end);
13121       p += len;
13122       printf ("  Tag_ABI_wchar_t: ");
13123       switch (val)
13124         {
13125         case 0:
13126           printf (_("Not used\n"));
13127           break;
13128         case 1:
13129           printf (_("2 bytes\n"));
13130           break;
13131         case 2:
13132           printf (_("4 bytes\n"));
13133           break;
13134         default:
13135           printf ("??? (%d)\n", val);
13136           break;
13137         }
13138       return p;
13139
13140     case Tag_ABI_stack_align_needed:
13141       val = read_uleb128 (p, &len, end);
13142       p += len;
13143       printf ("  Tag_ABI_stack_align_needed: ");
13144       switch (val)
13145         {
13146         case 0:
13147           printf (_("8-byte\n"));
13148           break;
13149         case 1:
13150           printf (_("16-byte\n"));
13151           break;
13152         default:
13153           printf ("??? (%d)\n", val);
13154           break;
13155         }
13156       return p;
13157
13158     case Tag_ABI_stack_align_preserved:
13159       val = read_uleb128 (p, &len, end);
13160       p += len;
13161       printf ("  Tag_ABI_stack_align_preserved: ");
13162       switch (val)
13163         {
13164         case 0:
13165           printf (_("8-byte\n"));
13166           break;
13167         case 1:
13168           printf (_("16-byte\n"));
13169           break;
13170         default:
13171           printf ("??? (%d)\n", val);
13172           break;
13173         }
13174       return p;
13175
13176     case Tag_ABI_DSBT:
13177       val = read_uleb128 (p, &len, end);
13178       p += len;
13179       printf ("  Tag_ABI_DSBT: ");
13180       switch (val)
13181         {
13182         case 0:
13183           printf (_("DSBT addressing not used\n"));
13184           break;
13185         case 1:
13186           printf (_("DSBT addressing used\n"));
13187           break;
13188         default:
13189           printf ("??? (%d)\n", val);
13190           break;
13191         }
13192       return p;
13193
13194     case Tag_ABI_PID:
13195       val = read_uleb128 (p, &len, end);
13196       p += len;
13197       printf ("  Tag_ABI_PID: ");
13198       switch (val)
13199         {
13200         case 0:
13201           printf (_("Data addressing position-dependent\n"));
13202           break;
13203         case 1:
13204           printf (_("Data addressing position-independent, GOT near DP\n"));
13205           break;
13206         case 2:
13207           printf (_("Data addressing position-independent, GOT far from DP\n"));
13208           break;
13209         default:
13210           printf ("??? (%d)\n", val);
13211           break;
13212         }
13213       return p;
13214
13215     case Tag_ABI_PIC:
13216       val = read_uleb128 (p, &len, end);
13217       p += len;
13218       printf ("  Tag_ABI_PIC: ");
13219       switch (val)
13220         {
13221         case 0:
13222           printf (_("Code addressing position-dependent\n"));
13223           break;
13224         case 1:
13225           printf (_("Code addressing position-independent\n"));
13226           break;
13227         default:
13228           printf ("??? (%d)\n", val);
13229           break;
13230         }
13231       return p;
13232
13233     case Tag_ABI_array_object_alignment:
13234       val = read_uleb128 (p, &len, end);
13235       p += len;
13236       printf ("  Tag_ABI_array_object_alignment: ");
13237       switch (val)
13238         {
13239         case 0:
13240           printf (_("8-byte\n"));
13241           break;
13242         case 1:
13243           printf (_("4-byte\n"));
13244           break;
13245         case 2:
13246           printf (_("16-byte\n"));
13247           break;
13248         default:
13249           printf ("??? (%d)\n", val);
13250           break;
13251         }
13252       return p;
13253
13254     case Tag_ABI_array_object_align_expected:
13255       val = read_uleb128 (p, &len, end);
13256       p += len;
13257       printf ("  Tag_ABI_array_object_align_expected: ");
13258       switch (val)
13259         {
13260         case 0:
13261           printf (_("8-byte\n"));
13262           break;
13263         case 1:
13264           printf (_("4-byte\n"));
13265           break;
13266         case 2:
13267           printf (_("16-byte\n"));
13268           break;
13269         default:
13270           printf ("??? (%d)\n", val);
13271           break;
13272         }
13273       return p;
13274
13275     case Tag_ABI_compatibility:
13276       {
13277         val = read_uleb128 (p, &len, end);
13278         p += len;
13279         printf ("  Tag_ABI_compatibility: ");
13280         printf (_("flag = %d, vendor = "), val);
13281         if (p < end - 1)
13282           {
13283             size_t maxlen = (end - p) - 1;
13284
13285             print_symbol ((int) maxlen, (const char *) p);
13286             p += strnlen ((char *) p, maxlen) + 1;
13287           }
13288         else
13289           {
13290             printf (_("<corrupt>"));
13291             p = (unsigned char *) end;
13292           }
13293         putchar ('\n');
13294         return p;
13295       }
13296
13297     case Tag_ABI_conformance:
13298       {
13299         printf ("  Tag_ABI_conformance: \"");
13300         if (p < end - 1)
13301           {
13302             size_t maxlen = (end - p) - 1;
13303
13304             print_symbol ((int) maxlen, (const char *) p);
13305             p += strnlen ((char *) p, maxlen) + 1;
13306           }
13307         else
13308           {
13309             printf (_("<corrupt>"));
13310             p = (unsigned char *) end;
13311           }
13312         printf ("\"\n");
13313         return p;
13314       }
13315     }
13316
13317   return display_tag_value (tag, p, end);
13318 }
13319
13320 static void
13321 display_raw_attribute (unsigned char * p, unsigned char * end)
13322 {
13323   unsigned long addr = 0;
13324   size_t bytes = end - p;
13325
13326   assert (end > p);
13327   while (bytes)
13328     {
13329       int j;
13330       int k;
13331       int lbytes = (bytes > 16 ? 16 : bytes);
13332
13333       printf ("  0x%8.8lx ", addr);
13334
13335       for (j = 0; j < 16; j++)
13336         {
13337           if (j < lbytes)
13338             printf ("%2.2x", p[j]);
13339           else
13340             printf ("  ");
13341
13342           if ((j & 3) == 3)
13343             printf (" ");
13344         }
13345
13346       for (j = 0; j < lbytes; j++)
13347         {
13348           k = p[j];
13349           if (k >= ' ' && k < 0x7f)
13350             printf ("%c", k);
13351           else
13352             printf (".");
13353         }
13354
13355       putchar ('\n');
13356
13357       p  += lbytes;
13358       bytes -= lbytes;
13359       addr += lbytes;
13360     }
13361
13362   putchar ('\n');
13363 }
13364
13365 static unsigned char *
13366 display_msp430x_attribute (unsigned char * p,
13367                            const unsigned char * const end)
13368 {
13369   unsigned int len;
13370   int val;
13371   int tag;
13372
13373   tag = read_uleb128 (p, & len, end);
13374   p += len;
13375
13376   switch (tag)
13377     {
13378     case OFBA_MSPABI_Tag_ISA:
13379       val = read_uleb128 (p, &len, end);
13380       p += len;
13381       printf ("  Tag_ISA: ");
13382       switch (val)
13383         {
13384         case 0: printf (_("None\n")); break;
13385         case 1: printf (_("MSP430\n")); break;
13386         case 2: printf (_("MSP430X\n")); break;
13387         default: printf ("??? (%d)\n", val); break;
13388         }
13389       break;
13390
13391     case OFBA_MSPABI_Tag_Code_Model:
13392       val = read_uleb128 (p, &len, end);
13393       p += len;
13394       printf ("  Tag_Code_Model: ");
13395       switch (val)
13396         {
13397         case 0: printf (_("None\n")); break;
13398         case 1: printf (_("Small\n")); break;
13399         case 2: printf (_("Large\n")); break;
13400         default: printf ("??? (%d)\n", val); break;
13401         }
13402       break;
13403
13404     case OFBA_MSPABI_Tag_Data_Model:
13405       val = read_uleb128 (p, &len, end);
13406       p += len;
13407       printf ("  Tag_Data_Model: ");
13408       switch (val)
13409         {
13410         case 0: printf (_("None\n")); break;
13411         case 1: printf (_("Small\n")); break;
13412         case 2: printf (_("Large\n")); break;
13413         case 3: printf (_("Restricted Large\n")); break;
13414         default: printf ("??? (%d)\n", val); break;
13415         }
13416       break;
13417
13418     default:
13419       printf (_("  <unknown tag %d>: "), tag);
13420
13421       if (tag & 1)
13422         {
13423           putchar ('"');
13424           if (p < end - 1)
13425             {
13426               size_t maxlen = (end - p) - 1;
13427
13428               print_symbol ((int) maxlen, (const char *) p);
13429               p += strnlen ((char *) p, maxlen) + 1;
13430             }
13431           else
13432             {
13433               printf (_("<corrupt>"));
13434               p = (unsigned char *) end;
13435             }
13436           printf ("\"\n");
13437         }
13438       else
13439         {
13440           val = read_uleb128 (p, &len, end);
13441           p += len;
13442           printf ("%d (0x%x)\n", val, val);
13443         }
13444       break;
13445    }
13446
13447   assert (p <= end);
13448   return p;
13449 }
13450
13451 static int
13452 process_attributes (FILE * file,
13453                     const char * public_name,
13454                     unsigned int proc_type,
13455                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13456                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13457 {
13458   Elf_Internal_Shdr * sect;
13459   unsigned i;
13460
13461   /* Find the section header so that we get the size.  */
13462   for (i = 0, sect = section_headers;
13463        i < elf_header.e_shnum;
13464        i++, sect++)
13465     {
13466       unsigned char * contents;
13467       unsigned char * p;
13468
13469       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13470         continue;
13471
13472       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13473                                              sect->sh_size, _("attributes"));
13474       if (contents == NULL)
13475         continue;
13476
13477       p = contents;
13478       if (*p == 'A')
13479         {
13480           bfd_vma section_len;
13481
13482           section_len = sect->sh_size - 1;
13483           p++;
13484
13485           while (section_len > 0)
13486             {
13487               bfd_vma attr_len;
13488               unsigned int namelen;
13489               bfd_boolean public_section;
13490               bfd_boolean gnu_section;
13491
13492               if (section_len <= 4)
13493                 {
13494                   error (_("Tag section ends prematurely\n"));
13495                   break;
13496                 }
13497               attr_len = byte_get (p, 4);
13498               p += 4;
13499
13500               if (attr_len > section_len)
13501                 {
13502                   error (_("Bad attribute length (%u > %u)\n"),
13503                           (unsigned) attr_len, (unsigned) section_len);
13504                   attr_len = section_len;
13505                 }
13506               /* PR 17531: file: 001-101425-0.004  */
13507               else if (attr_len < 5)
13508                 {
13509                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13510                   break;
13511                 }
13512
13513               section_len -= attr_len;
13514               attr_len -= 4;
13515
13516               namelen = strnlen ((char *) p, attr_len) + 1;
13517               if (namelen == 0 || namelen >= attr_len)
13518                 {
13519                   error (_("Corrupt attribute section name\n"));
13520                   break;
13521                 }
13522
13523               printf (_("Attribute Section: "));
13524               print_symbol (INT_MAX, (const char *) p);
13525               putchar ('\n');
13526
13527               if (public_name && streq ((char *) p, public_name))
13528                 public_section = TRUE;
13529               else
13530                 public_section = FALSE;
13531
13532               if (streq ((char *) p, "gnu"))
13533                 gnu_section = TRUE;
13534               else
13535                 gnu_section = FALSE;
13536
13537               p += namelen;
13538               attr_len -= namelen;
13539
13540               while (attr_len > 0 && p < contents + sect->sh_size)
13541                 {
13542                   int tag;
13543                   int val;
13544                   bfd_vma size;
13545                   unsigned char * end;
13546
13547                   /* PR binutils/17531: Safe handling of corrupt files.  */
13548                   if (attr_len < 6)
13549                     {
13550                       error (_("Unused bytes at end of section\n"));
13551                       section_len = 0;
13552                       break;
13553                     }
13554
13555                   tag = *(p++);
13556                   size = byte_get (p, 4);
13557                   if (size > attr_len)
13558                     {
13559                       error (_("Bad subsection length (%u > %u)\n"),
13560                               (unsigned) size, (unsigned) attr_len);
13561                       size = attr_len;
13562                     }
13563                   /* PR binutils/17531: Safe handling of corrupt files.  */
13564                   if (size < 6)
13565                     {
13566                       error (_("Bad subsection length (%u < 6)\n"),
13567                               (unsigned) size);
13568                       section_len = 0;
13569                       break;
13570                     }
13571
13572                   attr_len -= size;
13573                   end = p + size - 1;
13574                   assert (end <= contents + sect->sh_size);
13575                   p += 4;
13576
13577                   switch (tag)
13578                     {
13579                     case 1:
13580                       printf (_("File Attributes\n"));
13581                       break;
13582                     case 2:
13583                       printf (_("Section Attributes:"));
13584                       goto do_numlist;
13585                     case 3:
13586                       printf (_("Symbol Attributes:"));
13587                     do_numlist:
13588                       for (;;)
13589                         {
13590                           unsigned int j;
13591
13592                           val = read_uleb128 (p, &j, end);
13593                           p += j;
13594                           if (val == 0)
13595                             break;
13596                           printf (" %d", val);
13597                         }
13598                       printf ("\n");
13599                       break;
13600                     default:
13601                       printf (_("Unknown tag: %d\n"), tag);
13602                       public_section = FALSE;
13603                       break;
13604                     }
13605
13606                   if (public_section && display_pub_attribute != NULL)
13607                     {
13608                       while (p < end)
13609                         p = display_pub_attribute (p, end);
13610                       assert (p <= end);
13611                     }
13612                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13613                     {
13614                       while (p < end)
13615                         p = display_gnu_attribute (p,
13616                                                    display_proc_gnu_attribute,
13617                                                    end);
13618                       assert (p <= end);
13619                     }
13620                   else if (p < end)
13621                     {
13622                       printf (_("  Unknown attribute:\n"));
13623                       display_raw_attribute (p, end);
13624                       p = end;
13625                     }
13626                   else
13627                     attr_len = 0;
13628                 }
13629             }
13630         }
13631       else
13632         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13633
13634       free (contents);
13635     }
13636   return 1;
13637 }
13638
13639 static int
13640 process_arm_specific (FILE * file)
13641 {
13642   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13643                              display_arm_attribute, NULL);
13644 }
13645
13646 static int
13647 process_power_specific (FILE * file)
13648 {
13649   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13650                              display_power_gnu_attribute);
13651 }
13652
13653 static int
13654 process_s390_specific (FILE * file)
13655 {
13656   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13657                              display_s390_gnu_attribute);
13658 }
13659
13660 static int
13661 process_sparc_specific (FILE * file)
13662 {
13663   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13664                              display_sparc_gnu_attribute);
13665 }
13666
13667 static int
13668 process_tic6x_specific (FILE * file)
13669 {
13670   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13671                              display_tic6x_attribute, NULL);
13672 }
13673
13674 static int
13675 process_msp430x_specific (FILE * file)
13676 {
13677   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13678                              display_msp430x_attribute, NULL);
13679 }
13680
13681 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13682    Print the Address, Access and Initial fields of an entry at VMA ADDR
13683    and return the VMA of the next entry, or -1 if there was a problem.
13684    Does not read from DATA_END or beyond.  */
13685
13686 static bfd_vma
13687 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13688                       unsigned char * data_end)
13689 {
13690   printf ("  ");
13691   print_vma (addr, LONG_HEX);
13692   printf (" ");
13693   if (addr < pltgot + 0xfff0)
13694     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13695   else
13696     printf ("%10s", "");
13697   printf (" ");
13698   if (data == NULL)
13699     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13700   else
13701     {
13702       bfd_vma entry;
13703       unsigned char * from = data + addr - pltgot;
13704
13705       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13706         {
13707           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13708           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13709           return (bfd_vma) -1;
13710         }
13711       else
13712         {
13713           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13714           print_vma (entry, LONG_HEX);
13715         }
13716     }
13717   return addr + (is_32bit_elf ? 4 : 8);
13718 }
13719
13720 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13721    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13722    ADDR and return the VMA of the next entry.  */
13723
13724 static bfd_vma
13725 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13726 {
13727   printf ("  ");
13728   print_vma (addr, LONG_HEX);
13729   printf (" ");
13730   if (data == NULL)
13731     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13732   else
13733     {
13734       bfd_vma entry;
13735
13736       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13737       print_vma (entry, LONG_HEX);
13738     }
13739   return addr + (is_32bit_elf ? 4 : 8);
13740 }
13741
13742 static void
13743 print_mips_ases (unsigned int mask)
13744 {
13745   if (mask & AFL_ASE_DSP)
13746     fputs ("\n\tDSP ASE", stdout);
13747   if (mask & AFL_ASE_DSPR2)
13748     fputs ("\n\tDSP R2 ASE", stdout);
13749   if (mask & AFL_ASE_EVA)
13750     fputs ("\n\tEnhanced VA Scheme", stdout);
13751   if (mask & AFL_ASE_MCU)
13752     fputs ("\n\tMCU (MicroController) ASE", stdout);
13753   if (mask & AFL_ASE_MDMX)
13754     fputs ("\n\tMDMX ASE", stdout);
13755   if (mask & AFL_ASE_MIPS3D)
13756     fputs ("\n\tMIPS-3D ASE", stdout);
13757   if (mask & AFL_ASE_MT)
13758     fputs ("\n\tMT ASE", stdout);
13759   if (mask & AFL_ASE_SMARTMIPS)
13760     fputs ("\n\tSmartMIPS ASE", stdout);
13761   if (mask & AFL_ASE_VIRT)
13762     fputs ("\n\tVZ ASE", stdout);
13763   if (mask & AFL_ASE_MSA)
13764     fputs ("\n\tMSA ASE", stdout);
13765   if (mask & AFL_ASE_MIPS16)
13766     fputs ("\n\tMIPS16 ASE", stdout);
13767   if (mask & AFL_ASE_MICROMIPS)
13768     fputs ("\n\tMICROMIPS ASE", stdout);
13769   if (mask & AFL_ASE_XPA)
13770     fputs ("\n\tXPA ASE", stdout);
13771   if (mask == 0)
13772     fprintf (stdout, "\n\t%s", _("None"));
13773   else if ((mask & ~AFL_ASE_MASK) != 0)
13774     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13775 }
13776
13777 static void
13778 print_mips_isa_ext (unsigned int isa_ext)
13779 {
13780   switch (isa_ext)
13781     {
13782     case 0:
13783       fputs (_("None"), stdout);
13784       break;
13785     case AFL_EXT_XLR:
13786       fputs ("RMI XLR", stdout);
13787       break;
13788     case AFL_EXT_OCTEON3:
13789       fputs ("Cavium Networks Octeon3", stdout);
13790       break;
13791     case AFL_EXT_OCTEON2:
13792       fputs ("Cavium Networks Octeon2", stdout);
13793       break;
13794     case AFL_EXT_OCTEONP:
13795       fputs ("Cavium Networks OcteonP", stdout);
13796       break;
13797     case AFL_EXT_LOONGSON_3A:
13798       fputs ("Loongson 3A", stdout);
13799       break;
13800     case AFL_EXT_OCTEON:
13801       fputs ("Cavium Networks Octeon", stdout);
13802       break;
13803     case AFL_EXT_5900:
13804       fputs ("Toshiba R5900", stdout);
13805       break;
13806     case AFL_EXT_4650:
13807       fputs ("MIPS R4650", stdout);
13808       break;
13809     case AFL_EXT_4010:
13810       fputs ("LSI R4010", stdout);
13811       break;
13812     case AFL_EXT_4100:
13813       fputs ("NEC VR4100", stdout);
13814       break;
13815     case AFL_EXT_3900:
13816       fputs ("Toshiba R3900", stdout);
13817       break;
13818     case AFL_EXT_10000:
13819       fputs ("MIPS R10000", stdout);
13820       break;
13821     case AFL_EXT_SB1:
13822       fputs ("Broadcom SB-1", stdout);
13823       break;
13824     case AFL_EXT_4111:
13825       fputs ("NEC VR4111/VR4181", stdout);
13826       break;
13827     case AFL_EXT_4120:
13828       fputs ("NEC VR4120", stdout);
13829       break;
13830     case AFL_EXT_5400:
13831       fputs ("NEC VR5400", stdout);
13832       break;
13833     case AFL_EXT_5500:
13834       fputs ("NEC VR5500", stdout);
13835       break;
13836     case AFL_EXT_LOONGSON_2E:
13837       fputs ("ST Microelectronics Loongson 2E", stdout);
13838       break;
13839     case AFL_EXT_LOONGSON_2F:
13840       fputs ("ST Microelectronics Loongson 2F", stdout);
13841       break;
13842     default:
13843       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13844     }
13845 }
13846
13847 static int
13848 get_mips_reg_size (int reg_size)
13849 {
13850   return (reg_size == AFL_REG_NONE) ? 0
13851          : (reg_size == AFL_REG_32) ? 32
13852          : (reg_size == AFL_REG_64) ? 64
13853          : (reg_size == AFL_REG_128) ? 128
13854          : -1;
13855 }
13856
13857 static int
13858 process_mips_specific (FILE * file)
13859 {
13860   Elf_Internal_Dyn * entry;
13861   Elf_Internal_Shdr *sect = NULL;
13862   size_t liblist_offset = 0;
13863   size_t liblistno = 0;
13864   size_t conflictsno = 0;
13865   size_t options_offset = 0;
13866   size_t conflicts_offset = 0;
13867   size_t pltrelsz = 0;
13868   size_t pltrel = 0;
13869   bfd_vma pltgot = 0;
13870   bfd_vma mips_pltgot = 0;
13871   bfd_vma jmprel = 0;
13872   bfd_vma local_gotno = 0;
13873   bfd_vma gotsym = 0;
13874   bfd_vma symtabno = 0;
13875
13876   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13877                       display_mips_gnu_attribute);
13878
13879   sect = find_section (".MIPS.abiflags");
13880
13881   if (sect != NULL)
13882     {
13883       Elf_External_ABIFlags_v0 *abiflags_ext;
13884       Elf_Internal_ABIFlags_v0 abiflags_in;
13885
13886       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13887         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13888       else
13889         {
13890           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13891                                    sect->sh_size, _("MIPS ABI Flags section"));
13892           if (abiflags_ext)
13893             {
13894               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13895               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13896               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13897               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13898               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13899               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13900               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13901               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13902               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13903               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13904               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13905
13906               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13907               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13908               if (abiflags_in.isa_rev > 1)
13909                 printf ("r%d", abiflags_in.isa_rev);
13910               printf ("\nGPR size: %d",
13911                       get_mips_reg_size (abiflags_in.gpr_size));
13912               printf ("\nCPR1 size: %d",
13913                       get_mips_reg_size (abiflags_in.cpr1_size));
13914               printf ("\nCPR2 size: %d",
13915                       get_mips_reg_size (abiflags_in.cpr2_size));
13916               fputs ("\nFP ABI: ", stdout);
13917               print_mips_fp_abi_value (abiflags_in.fp_abi);
13918               fputs ("ISA Extension: ", stdout);
13919               print_mips_isa_ext (abiflags_in.isa_ext);
13920               fputs ("\nASEs:", stdout);
13921               print_mips_ases (abiflags_in.ases);
13922               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13923               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13924               fputc ('\n', stdout);
13925               free (abiflags_ext);
13926             }
13927         }
13928     }
13929
13930   /* We have a lot of special sections.  Thanks SGI!  */
13931   if (dynamic_section == NULL)
13932     /* No information available.  */
13933     return 0;
13934
13935   for (entry = dynamic_section;
13936        /* PR 17531 file: 012-50589-0.004.  */
13937        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13938        ++entry)
13939     switch (entry->d_tag)
13940       {
13941       case DT_MIPS_LIBLIST:
13942         liblist_offset
13943           = offset_from_vma (file, entry->d_un.d_val,
13944                              liblistno * sizeof (Elf32_External_Lib));
13945         break;
13946       case DT_MIPS_LIBLISTNO:
13947         liblistno = entry->d_un.d_val;
13948         break;
13949       case DT_MIPS_OPTIONS:
13950         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13951         break;
13952       case DT_MIPS_CONFLICT:
13953         conflicts_offset
13954           = offset_from_vma (file, entry->d_un.d_val,
13955                              conflictsno * sizeof (Elf32_External_Conflict));
13956         break;
13957       case DT_MIPS_CONFLICTNO:
13958         conflictsno = entry->d_un.d_val;
13959         break;
13960       case DT_PLTGOT:
13961         pltgot = entry->d_un.d_ptr;
13962         break;
13963       case DT_MIPS_LOCAL_GOTNO:
13964         local_gotno = entry->d_un.d_val;
13965         break;
13966       case DT_MIPS_GOTSYM:
13967         gotsym = entry->d_un.d_val;
13968         break;
13969       case DT_MIPS_SYMTABNO:
13970         symtabno = entry->d_un.d_val;
13971         break;
13972       case DT_MIPS_PLTGOT:
13973         mips_pltgot = entry->d_un.d_ptr;
13974         break;
13975       case DT_PLTREL:
13976         pltrel = entry->d_un.d_val;
13977         break;
13978       case DT_PLTRELSZ:
13979         pltrelsz = entry->d_un.d_val;
13980         break;
13981       case DT_JMPREL:
13982         jmprel = entry->d_un.d_ptr;
13983         break;
13984       default:
13985         break;
13986       }
13987
13988   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13989     {
13990       Elf32_External_Lib * elib;
13991       size_t cnt;
13992
13993       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13994                                               liblistno,
13995                                               sizeof (Elf32_External_Lib),
13996                                               _("liblist section data"));
13997       if (elib)
13998         {
13999           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14000                   (unsigned long) liblistno);
14001           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14002                  stdout);
14003
14004           for (cnt = 0; cnt < liblistno; ++cnt)
14005             {
14006               Elf32_Lib liblist;
14007               time_t atime;
14008               char timebuf[20];
14009               struct tm * tmp;
14010
14011               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14012               atime = BYTE_GET (elib[cnt].l_time_stamp);
14013               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14014               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14015               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14016
14017               tmp = gmtime (&atime);
14018               snprintf (timebuf, sizeof (timebuf),
14019                         "%04u-%02u-%02uT%02u:%02u:%02u",
14020                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14021                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14022
14023               printf ("%3lu: ", (unsigned long) cnt);
14024               if (VALID_DYNAMIC_NAME (liblist.l_name))
14025                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14026               else
14027                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14028               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14029                       liblist.l_version);
14030
14031               if (liblist.l_flags == 0)
14032                 puts (_(" NONE"));
14033               else
14034                 {
14035                   static const struct
14036                   {
14037                     const char * name;
14038                     int bit;
14039                   }
14040                   l_flags_vals[] =
14041                   {
14042                     { " EXACT_MATCH", LL_EXACT_MATCH },
14043                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14044                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14045                     { " EXPORTS", LL_EXPORTS },
14046                     { " DELAY_LOAD", LL_DELAY_LOAD },
14047                     { " DELTA", LL_DELTA }
14048                   };
14049                   int flags = liblist.l_flags;
14050                   size_t fcnt;
14051
14052                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14053                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14054                       {
14055                         fputs (l_flags_vals[fcnt].name, stdout);
14056                         flags ^= l_flags_vals[fcnt].bit;
14057                       }
14058                   if (flags != 0)
14059                     printf (" %#x", (unsigned int) flags);
14060
14061                   puts ("");
14062                 }
14063             }
14064
14065           free (elib);
14066         }
14067     }
14068
14069   if (options_offset != 0)
14070     {
14071       Elf_External_Options * eopt;
14072       Elf_Internal_Options * iopt;
14073       Elf_Internal_Options * option;
14074       size_t offset;
14075       int cnt;
14076       sect = section_headers;
14077
14078       /* Find the section header so that we get the size.  */
14079       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14080       /* PR 17533 file: 012-277276-0.004.  */
14081       if (sect == NULL)
14082         {
14083           error (_("No MIPS_OPTIONS header found\n"));
14084           return 0;
14085         }
14086
14087       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14088                                                 sect->sh_size, _("options"));
14089       if (eopt)
14090         {
14091           iopt = (Elf_Internal_Options *)
14092               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14093           if (iopt == NULL)
14094             {
14095               error (_("Out of memory allocatinf space for MIPS options\n"));
14096               return 0;
14097             }
14098
14099           offset = cnt = 0;
14100           option = iopt;
14101
14102           while (offset <= sect->sh_size - sizeof (* eopt))
14103             {
14104               Elf_External_Options * eoption;
14105
14106               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14107
14108               option->kind = BYTE_GET (eoption->kind);
14109               option->size = BYTE_GET (eoption->size);
14110               option->section = BYTE_GET (eoption->section);
14111               option->info = BYTE_GET (eoption->info);
14112
14113               /* PR 17531: file: ffa0fa3b.  */
14114               if (option->size < sizeof (* eopt)
14115                   || offset + option->size > sect->sh_size)
14116                 {
14117                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14118                   return 0;
14119                 }
14120               offset += option->size;
14121
14122               ++option;
14123               ++cnt;
14124             }
14125
14126           printf (_("\nSection '%s' contains %d entries:\n"),
14127                   printable_section_name (sect), cnt);
14128
14129           option = iopt;
14130           offset = 0;
14131
14132           while (cnt-- > 0)
14133             {
14134               size_t len;
14135
14136               switch (option->kind)
14137                 {
14138                 case ODK_NULL:
14139                   /* This shouldn't happen.  */
14140                   printf (" NULL       %d %lx", option->section, option->info);
14141                   break;
14142                 case ODK_REGINFO:
14143                   printf (" REGINFO    ");
14144                   if (elf_header.e_machine == EM_MIPS)
14145                     {
14146                       /* 32bit form.  */
14147                       Elf32_External_RegInfo * ereg;
14148                       Elf32_RegInfo reginfo;
14149
14150                       ereg = (Elf32_External_RegInfo *) (option + 1);
14151                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14152                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14153                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14154                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14155                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14156                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14157
14158                       printf ("GPR %08lx  GP 0x%lx\n",
14159                               reginfo.ri_gprmask,
14160                               (unsigned long) reginfo.ri_gp_value);
14161                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14162                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14163                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14164                     }
14165                   else
14166                     {
14167                       /* 64 bit form.  */
14168                       Elf64_External_RegInfo * ereg;
14169                       Elf64_Internal_RegInfo reginfo;
14170
14171                       ereg = (Elf64_External_RegInfo *) (option + 1);
14172                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14173                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14174                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14175                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14176                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14177                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14178
14179                       printf ("GPR %08lx  GP 0x",
14180                               reginfo.ri_gprmask);
14181                       printf_vma (reginfo.ri_gp_value);
14182                       printf ("\n");
14183
14184                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14185                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14186                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14187                     }
14188                   ++option;
14189                   continue;
14190                 case ODK_EXCEPTIONS:
14191                   fputs (" EXCEPTIONS fpe_min(", stdout);
14192                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14193                   fputs (") fpe_max(", stdout);
14194                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14195                   fputs (")", stdout);
14196
14197                   if (option->info & OEX_PAGE0)
14198                     fputs (" PAGE0", stdout);
14199                   if (option->info & OEX_SMM)
14200                     fputs (" SMM", stdout);
14201                   if (option->info & OEX_FPDBUG)
14202                     fputs (" FPDBUG", stdout);
14203                   if (option->info & OEX_DISMISS)
14204                     fputs (" DISMISS", stdout);
14205                   break;
14206                 case ODK_PAD:
14207                   fputs (" PAD       ", stdout);
14208                   if (option->info & OPAD_PREFIX)
14209                     fputs (" PREFIX", stdout);
14210                   if (option->info & OPAD_POSTFIX)
14211                     fputs (" POSTFIX", stdout);
14212                   if (option->info & OPAD_SYMBOL)
14213                     fputs (" SYMBOL", stdout);
14214                   break;
14215                 case ODK_HWPATCH:
14216                   fputs (" HWPATCH   ", stdout);
14217                   if (option->info & OHW_R4KEOP)
14218                     fputs (" R4KEOP", stdout);
14219                   if (option->info & OHW_R8KPFETCH)
14220                     fputs (" R8KPFETCH", stdout);
14221                   if (option->info & OHW_R5KEOP)
14222                     fputs (" R5KEOP", stdout);
14223                   if (option->info & OHW_R5KCVTL)
14224                     fputs (" R5KCVTL", stdout);
14225                   break;
14226                 case ODK_FILL:
14227                   fputs (" FILL       ", stdout);
14228                   /* XXX Print content of info word?  */
14229                   break;
14230                 case ODK_TAGS:
14231                   fputs (" TAGS       ", stdout);
14232                   /* XXX Print content of info word?  */
14233                   break;
14234                 case ODK_HWAND:
14235                   fputs (" HWAND     ", stdout);
14236                   if (option->info & OHWA0_R4KEOP_CHECKED)
14237                     fputs (" R4KEOP_CHECKED", stdout);
14238                   if (option->info & OHWA0_R4KEOP_CLEAN)
14239                     fputs (" R4KEOP_CLEAN", stdout);
14240                   break;
14241                 case ODK_HWOR:
14242                   fputs (" HWOR      ", stdout);
14243                   if (option->info & OHWA0_R4KEOP_CHECKED)
14244                     fputs (" R4KEOP_CHECKED", stdout);
14245                   if (option->info & OHWA0_R4KEOP_CLEAN)
14246                     fputs (" R4KEOP_CLEAN", stdout);
14247                   break;
14248                 case ODK_GP_GROUP:
14249                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14250                           option->info & OGP_GROUP,
14251                           (option->info & OGP_SELF) >> 16);
14252                   break;
14253                 case ODK_IDENT:
14254                   printf (" IDENT     %#06lx  self-contained %#06lx",
14255                           option->info & OGP_GROUP,
14256                           (option->info & OGP_SELF) >> 16);
14257                   break;
14258                 default:
14259                   /* This shouldn't happen.  */
14260                   printf (" %3d ???     %d %lx",
14261                           option->kind, option->section, option->info);
14262                   break;
14263                 }
14264
14265               len = sizeof (* eopt);
14266               while (len < option->size)
14267                 {
14268                   char datum = * ((char *) eopt + offset + len);
14269
14270                   if (ISPRINT (datum))
14271                     printf ("%c", datum);
14272                   else
14273                     printf ("\\%03o", datum);
14274                   len ++;
14275                 }
14276               fputs ("\n", stdout);
14277
14278               offset += option->size;
14279               ++option;
14280             }
14281
14282           free (eopt);
14283         }
14284     }
14285
14286   if (conflicts_offset != 0 && conflictsno != 0)
14287     {
14288       Elf32_Conflict * iconf;
14289       size_t cnt;
14290
14291       if (dynamic_symbols == NULL)
14292         {
14293           error (_("conflict list found without a dynamic symbol table\n"));
14294           return 0;
14295         }
14296
14297       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14298       if (iconf == NULL)
14299         {
14300           error (_("Out of memory allocating space for dynamic conflicts\n"));
14301           return 0;
14302         }
14303
14304       if (is_32bit_elf)
14305         {
14306           Elf32_External_Conflict * econf32;
14307
14308           econf32 = (Elf32_External_Conflict *)
14309               get_data (NULL, file, conflicts_offset, conflictsno,
14310                         sizeof (* econf32), _("conflict"));
14311           if (!econf32)
14312             return 0;
14313
14314           for (cnt = 0; cnt < conflictsno; ++cnt)
14315             iconf[cnt] = BYTE_GET (econf32[cnt]);
14316
14317           free (econf32);
14318         }
14319       else
14320         {
14321           Elf64_External_Conflict * econf64;
14322
14323           econf64 = (Elf64_External_Conflict *)
14324               get_data (NULL, file, conflicts_offset, conflictsno,
14325                         sizeof (* econf64), _("conflict"));
14326           if (!econf64)
14327             return 0;
14328
14329           for (cnt = 0; cnt < conflictsno; ++cnt)
14330             iconf[cnt] = BYTE_GET (econf64[cnt]);
14331
14332           free (econf64);
14333         }
14334
14335       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14336               (unsigned long) conflictsno);
14337       puts (_("  Num:    Index       Value  Name"));
14338
14339       for (cnt = 0; cnt < conflictsno; ++cnt)
14340         {
14341           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14342
14343           if (iconf[cnt] >= num_dynamic_syms)
14344             printf (_("<corrupt symbol index>"));
14345           else
14346             {
14347               Elf_Internal_Sym * psym;
14348
14349               psym = & dynamic_symbols[iconf[cnt]];
14350               print_vma (psym->st_value, FULL_HEX);
14351               putchar (' ');
14352               if (VALID_DYNAMIC_NAME (psym->st_name))
14353                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14354               else
14355                 printf (_("<corrupt: %14ld>"), psym->st_name);
14356             }
14357           putchar ('\n');
14358         }
14359
14360       free (iconf);
14361     }
14362
14363   if (pltgot != 0 && local_gotno != 0)
14364     {
14365       bfd_vma ent, local_end, global_end;
14366       size_t i, offset;
14367       unsigned char * data;
14368       unsigned char * data_end;
14369       int addr_size;
14370
14371       ent = pltgot;
14372       addr_size = (is_32bit_elf ? 4 : 8);
14373       local_end = pltgot + local_gotno * addr_size;
14374
14375       /* PR binutils/17533 file: 012-111227-0.004  */
14376       if (symtabno < gotsym)
14377         {
14378           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14379                  (unsigned long) gotsym, (unsigned long) symtabno);
14380           return 0;
14381         }
14382
14383       global_end = local_end + (symtabno - gotsym) * addr_size;
14384       /* PR 17531: file: 54c91a34.  */
14385       if (global_end < local_end)
14386         {
14387           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14388           return 0;
14389         }
14390
14391       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14392       data = (unsigned char *) get_data (NULL, file, offset,
14393                                          global_end - pltgot, 1,
14394                                          _("Global Offset Table data"));
14395       if (data == NULL)
14396         return 0;
14397       data_end = data + (global_end - pltgot);
14398
14399       printf (_("\nPrimary GOT:\n"));
14400       printf (_(" Canonical gp value: "));
14401       print_vma (pltgot + 0x7ff0, LONG_HEX);
14402       printf ("\n\n");
14403
14404       printf (_(" Reserved entries:\n"));
14405       printf (_("  %*s %10s %*s Purpose\n"),
14406               addr_size * 2, _("Address"), _("Access"),
14407               addr_size * 2, _("Initial"));
14408       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14409       printf (_(" Lazy resolver\n"));
14410       if (ent == (bfd_vma) -1)
14411         goto got_print_fail;
14412       if (data
14413           && (byte_get (data + ent - pltgot, addr_size)
14414               >> (addr_size * 8 - 1)) != 0)
14415         {
14416           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14417           printf (_(" Module pointer (GNU extension)\n"));
14418           if (ent == (bfd_vma) -1)
14419             goto got_print_fail;
14420         }
14421       printf ("\n");
14422
14423       if (ent < local_end)
14424         {
14425           printf (_(" Local entries:\n"));
14426           printf ("  %*s %10s %*s\n",
14427                   addr_size * 2, _("Address"), _("Access"),
14428                   addr_size * 2, _("Initial"));
14429           while (ent < local_end)
14430             {
14431               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14432               printf ("\n");
14433               if (ent == (bfd_vma) -1)
14434                 goto got_print_fail;
14435             }
14436           printf ("\n");
14437         }
14438
14439       if (gotsym < symtabno)
14440         {
14441           int sym_width;
14442
14443           printf (_(" Global entries:\n"));
14444           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14445                   addr_size * 2, _("Address"),
14446                   _("Access"),
14447                   addr_size * 2, _("Initial"),
14448                   addr_size * 2, _("Sym.Val."),
14449                   _("Type"),
14450                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14451                   _("Ndx"), _("Name"));
14452
14453           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14454
14455           for (i = gotsym; i < symtabno; i++)
14456             {
14457               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14458               printf (" ");
14459
14460               if (dynamic_symbols == NULL)
14461                 printf (_("<no dynamic symbols>"));
14462               else if (i < num_dynamic_syms)
14463                 {
14464                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14465
14466                   print_vma (psym->st_value, LONG_HEX);
14467                   printf (" %-7s %3s ",
14468                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14469                           get_symbol_index_type (psym->st_shndx));
14470
14471                   if (VALID_DYNAMIC_NAME (psym->st_name))
14472                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14473                   else
14474                     printf (_("<corrupt: %14ld>"), psym->st_name);
14475                 }
14476               else
14477                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14478                         (unsigned long) i);
14479
14480               printf ("\n");
14481               if (ent == (bfd_vma) -1)
14482                 break;
14483             }
14484           printf ("\n");
14485         }
14486
14487     got_print_fail:
14488       if (data)
14489         free (data);
14490     }
14491
14492   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14493     {
14494       bfd_vma ent, end;
14495       size_t offset, rel_offset;
14496       unsigned long count, i;
14497       unsigned char * data;
14498       int addr_size, sym_width;
14499       Elf_Internal_Rela * rels;
14500
14501       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14502       if (pltrel == DT_RELA)
14503         {
14504           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14505             return 0;
14506         }
14507       else
14508         {
14509           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14510             return 0;
14511         }
14512
14513       ent = mips_pltgot;
14514       addr_size = (is_32bit_elf ? 4 : 8);
14515       end = mips_pltgot + (2 + count) * addr_size;
14516
14517       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14518       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14519                                          1, _("Procedure Linkage Table data"));
14520       if (data == NULL)
14521         return 0;
14522
14523       printf ("\nPLT GOT:\n\n");
14524       printf (_(" Reserved entries:\n"));
14525       printf (_("  %*s %*s Purpose\n"),
14526               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14527       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14528       printf (_(" PLT lazy resolver\n"));
14529       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14530       printf (_(" Module pointer\n"));
14531       printf ("\n");
14532
14533       printf (_(" Entries:\n"));
14534       printf ("  %*s %*s %*s %-7s %3s %s\n",
14535               addr_size * 2, _("Address"),
14536               addr_size * 2, _("Initial"),
14537               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14538       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14539       for (i = 0; i < count; i++)
14540         {
14541           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14542
14543           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14544           printf (" ");
14545
14546           if (idx >= num_dynamic_syms)
14547             printf (_("<corrupt symbol index: %lu>"), idx);
14548           else
14549             {
14550               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14551
14552               print_vma (psym->st_value, LONG_HEX);
14553               printf (" %-7s %3s ",
14554                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14555                       get_symbol_index_type (psym->st_shndx));
14556               if (VALID_DYNAMIC_NAME (psym->st_name))
14557                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14558               else
14559                 printf (_("<corrupt: %14ld>"), psym->st_name);
14560             }
14561           printf ("\n");
14562         }
14563       printf ("\n");
14564
14565       if (data)
14566         free (data);
14567       free (rels);
14568     }
14569
14570   return 1;
14571 }
14572
14573 static int
14574 process_nds32_specific (FILE * file)
14575 {
14576   Elf_Internal_Shdr *sect = NULL;
14577
14578   sect = find_section (".nds32_e_flags");
14579   if (sect != NULL)
14580     {
14581       unsigned int *flag;
14582
14583       printf ("\nNDS32 elf flags section:\n");
14584       flag = get_data (NULL, file, sect->sh_offset, 1,
14585                        sect->sh_size, _("NDS32 elf flags section"));
14586
14587       switch ((*flag) & 0x3)
14588         {
14589         case 0:
14590           printf ("(VEC_SIZE):\tNo entry.\n");
14591           break;
14592         case 1:
14593           printf ("(VEC_SIZE):\t4 bytes\n");
14594           break;
14595         case 2:
14596           printf ("(VEC_SIZE):\t16 bytes\n");
14597           break;
14598         case 3:
14599           printf ("(VEC_SIZE):\treserved\n");
14600           break;
14601         }
14602     }
14603
14604   return TRUE;
14605 }
14606
14607 static int
14608 process_gnu_liblist (FILE * file)
14609 {
14610   Elf_Internal_Shdr * section;
14611   Elf_Internal_Shdr * string_sec;
14612   Elf32_External_Lib * elib;
14613   char * strtab;
14614   size_t strtab_size;
14615   size_t cnt;
14616   unsigned i;
14617
14618   if (! do_arch)
14619     return 0;
14620
14621   for (i = 0, section = section_headers;
14622        i < elf_header.e_shnum;
14623        i++, section++)
14624     {
14625       switch (section->sh_type)
14626         {
14627         case SHT_GNU_LIBLIST:
14628           if (section->sh_link >= elf_header.e_shnum)
14629             break;
14630
14631           elib = (Elf32_External_Lib *)
14632               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14633                         _("liblist section data"));
14634
14635           if (elib == NULL)
14636             break;
14637           string_sec = section_headers + section->sh_link;
14638
14639           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14640                                       string_sec->sh_size,
14641                                       _("liblist string table"));
14642           if (strtab == NULL
14643               || section->sh_entsize != sizeof (Elf32_External_Lib))
14644             {
14645               free (elib);
14646               free (strtab);
14647               break;
14648             }
14649           strtab_size = string_sec->sh_size;
14650
14651           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14652                   printable_section_name (section),
14653                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14654
14655           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14656
14657           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14658                ++cnt)
14659             {
14660               Elf32_Lib liblist;
14661               time_t atime;
14662               char timebuf[20];
14663               struct tm * tmp;
14664
14665               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14666               atime = BYTE_GET (elib[cnt].l_time_stamp);
14667               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14668               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14669               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14670
14671               tmp = gmtime (&atime);
14672               snprintf (timebuf, sizeof (timebuf),
14673                         "%04u-%02u-%02uT%02u:%02u:%02u",
14674                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14675                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14676
14677               printf ("%3lu: ", (unsigned long) cnt);
14678               if (do_wide)
14679                 printf ("%-20s", liblist.l_name < strtab_size
14680                         ? strtab + liblist.l_name : _("<corrupt>"));
14681               else
14682                 printf ("%-20.20s", liblist.l_name < strtab_size
14683                         ? strtab + liblist.l_name : _("<corrupt>"));
14684               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14685                       liblist.l_version, liblist.l_flags);
14686             }
14687
14688           free (elib);
14689           free (strtab);
14690         }
14691     }
14692
14693   return 1;
14694 }
14695
14696 static const char *
14697 get_note_type (unsigned e_type)
14698 {
14699   static char buff[64];
14700
14701   if (elf_header.e_type == ET_CORE)
14702     switch (e_type)
14703       {
14704       case NT_AUXV:
14705         return _("NT_AUXV (auxiliary vector)");
14706       case NT_PRSTATUS:
14707         return _("NT_PRSTATUS (prstatus structure)");
14708       case NT_FPREGSET:
14709         return _("NT_FPREGSET (floating point registers)");
14710       case NT_PRPSINFO:
14711         return _("NT_PRPSINFO (prpsinfo structure)");
14712       case NT_TASKSTRUCT:
14713         return _("NT_TASKSTRUCT (task structure)");
14714       case NT_PRXFPREG:
14715         return _("NT_PRXFPREG (user_xfpregs structure)");
14716       case NT_PPC_VMX:
14717         return _("NT_PPC_VMX (ppc Altivec registers)");
14718       case NT_PPC_VSX:
14719         return _("NT_PPC_VSX (ppc VSX registers)");
14720       case NT_386_TLS:
14721         return _("NT_386_TLS (x86 TLS information)");
14722       case NT_386_IOPERM:
14723         return _("NT_386_IOPERM (x86 I/O permissions)");
14724       case NT_X86_XSTATE:
14725         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14726       case NT_S390_HIGH_GPRS:
14727         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14728       case NT_S390_TIMER:
14729         return _("NT_S390_TIMER (s390 timer register)");
14730       case NT_S390_TODCMP:
14731         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14732       case NT_S390_TODPREG:
14733         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14734       case NT_S390_CTRS:
14735         return _("NT_S390_CTRS (s390 control registers)");
14736       case NT_S390_PREFIX:
14737         return _("NT_S390_PREFIX (s390 prefix register)");
14738       case NT_S390_LAST_BREAK:
14739         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14740       case NT_S390_SYSTEM_CALL:
14741         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14742       case NT_S390_TDB:
14743         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14744       case NT_S390_VXRS_LOW:
14745         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14746       case NT_S390_VXRS_HIGH:
14747         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14748       case NT_ARM_VFP:
14749         return _("NT_ARM_VFP (arm VFP registers)");
14750       case NT_ARM_TLS:
14751         return _("NT_ARM_TLS (AArch TLS registers)");
14752       case NT_ARM_HW_BREAK:
14753         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14754       case NT_ARM_HW_WATCH:
14755         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14756       case NT_PSTATUS:
14757         return _("NT_PSTATUS (pstatus structure)");
14758       case NT_FPREGS:
14759         return _("NT_FPREGS (floating point registers)");
14760       case NT_PSINFO:
14761         return _("NT_PSINFO (psinfo structure)");
14762       case NT_LWPSTATUS:
14763         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14764       case NT_LWPSINFO:
14765         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14766       case NT_WIN32PSTATUS:
14767         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14768       case NT_SIGINFO:
14769         return _("NT_SIGINFO (siginfo_t data)");
14770       case NT_FILE:
14771         return _("NT_FILE (mapped files)");
14772       default:
14773         break;
14774       }
14775   else
14776     switch (e_type)
14777       {
14778       case NT_VERSION:
14779         return _("NT_VERSION (version)");
14780       case NT_ARCH:
14781         return _("NT_ARCH (architecture)");
14782       default:
14783         break;
14784       }
14785
14786   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14787   return buff;
14788 }
14789
14790 static int
14791 print_core_note (Elf_Internal_Note *pnote)
14792 {
14793   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14794   bfd_vma count, page_size;
14795   unsigned char *descdata, *filenames, *descend;
14796
14797   if (pnote->type != NT_FILE)
14798     return 1;
14799
14800 #ifndef BFD64
14801   if (!is_32bit_elf)
14802     {
14803       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14804       /* Still "successful".  */
14805       return 1;
14806     }
14807 #endif
14808
14809   if (pnote->descsz < 2 * addr_size)
14810     {
14811       printf (_("    Malformed note - too short for header\n"));
14812       return 0;
14813     }
14814
14815   descdata = (unsigned char *) pnote->descdata;
14816   descend = descdata + pnote->descsz;
14817
14818   if (descdata[pnote->descsz - 1] != '\0')
14819     {
14820       printf (_("    Malformed note - does not end with \\0\n"));
14821       return 0;
14822     }
14823
14824   count = byte_get (descdata, addr_size);
14825   descdata += addr_size;
14826
14827   page_size = byte_get (descdata, addr_size);
14828   descdata += addr_size;
14829
14830   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14831     {
14832       printf (_("    Malformed note - too short for supplied file count\n"));
14833       return 0;
14834     }
14835
14836   printf (_("    Page size: "));
14837   print_vma (page_size, DEC);
14838   printf ("\n");
14839
14840   printf (_("    %*s%*s%*s\n"),
14841           (int) (2 + 2 * addr_size), _("Start"),
14842           (int) (4 + 2 * addr_size), _("End"),
14843           (int) (4 + 2 * addr_size), _("Page Offset"));
14844   filenames = descdata + count * 3 * addr_size;
14845   while (--count > 0)
14846     {
14847       bfd_vma start, end, file_ofs;
14848
14849       if (filenames == descend)
14850         {
14851           printf (_("    Malformed note - filenames end too early\n"));
14852           return 0;
14853         }
14854
14855       start = byte_get (descdata, addr_size);
14856       descdata += addr_size;
14857       end = byte_get (descdata, addr_size);
14858       descdata += addr_size;
14859       file_ofs = byte_get (descdata, addr_size);
14860       descdata += addr_size;
14861
14862       printf ("    ");
14863       print_vma (start, FULL_HEX);
14864       printf ("  ");
14865       print_vma (end, FULL_HEX);
14866       printf ("  ");
14867       print_vma (file_ofs, FULL_HEX);
14868       printf ("\n        %s\n", filenames);
14869
14870       filenames += 1 + strlen ((char *) filenames);
14871     }
14872
14873   return 1;
14874 }
14875
14876 static const char *
14877 get_gnu_elf_note_type (unsigned e_type)
14878 {
14879   static char buff[64];
14880
14881   switch (e_type)
14882     {
14883     case NT_GNU_ABI_TAG:
14884       return _("NT_GNU_ABI_TAG (ABI version tag)");
14885     case NT_GNU_HWCAP:
14886       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14887     case NT_GNU_BUILD_ID:
14888       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14889     case NT_GNU_GOLD_VERSION:
14890       return _("NT_GNU_GOLD_VERSION (gold version)");
14891     default:
14892       break;
14893     }
14894
14895   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14896   return buff;
14897 }
14898
14899 static int
14900 print_gnu_note (Elf_Internal_Note *pnote)
14901 {
14902   switch (pnote->type)
14903     {
14904     case NT_GNU_BUILD_ID:
14905       {
14906         unsigned long i;
14907
14908         printf (_("    Build ID: "));
14909         for (i = 0; i < pnote->descsz; ++i)
14910           printf ("%02x", pnote->descdata[i] & 0xff);
14911         printf ("\n");
14912       }
14913       break;
14914
14915     case NT_GNU_ABI_TAG:
14916       {
14917         unsigned long os, major, minor, subminor;
14918         const char *osname;
14919
14920         /* PR 17531: file: 030-599401-0.004.  */
14921         if (pnote->descsz < 16)
14922           {
14923             printf (_("    <corrupt GNU_ABI_TAG>\n"));
14924             break;
14925           }
14926
14927         os = byte_get ((unsigned char *) pnote->descdata, 4);
14928         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14929         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14930         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14931
14932         switch (os)
14933           {
14934           case GNU_ABI_TAG_LINUX:
14935             osname = "Linux";
14936             break;
14937           case GNU_ABI_TAG_HURD:
14938             osname = "Hurd";
14939             break;
14940           case GNU_ABI_TAG_SOLARIS:
14941             osname = "Solaris";
14942             break;
14943           case GNU_ABI_TAG_FREEBSD:
14944             osname = "FreeBSD";
14945             break;
14946           case GNU_ABI_TAG_NETBSD:
14947             osname = "NetBSD";
14948             break;
14949           default:
14950             osname = "Unknown";
14951             break;
14952           }
14953
14954         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14955                 major, minor, subminor);
14956       }
14957       break;
14958
14959     case NT_GNU_GOLD_VERSION:
14960       {
14961         unsigned long i;
14962
14963         printf (_("    Version: "));
14964         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14965           printf ("%c", pnote->descdata[i]);
14966         printf ("\n");
14967       }
14968       break;
14969     }
14970
14971   return 1;
14972 }
14973
14974 static const char *
14975 get_v850_elf_note_type (enum v850_notes n_type)
14976 {
14977   static char buff[64];
14978
14979   switch (n_type)
14980     {
14981     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
14982     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
14983     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
14984     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
14985     case V850_NOTE_CACHE_INFO: return _("Use of cache");
14986     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
14987     default:
14988       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14989       return buff;
14990     }
14991 }
14992
14993 static int
14994 print_v850_note (Elf_Internal_Note * pnote)
14995 {
14996   unsigned int val;
14997
14998   if (pnote->descsz != 4)
14999     return 0;
15000   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15001
15002   if (val == 0)
15003     {
15004       printf (_("not set\n"));
15005       return 1;
15006     }
15007
15008   switch (pnote->type)
15009     {
15010     case V850_NOTE_ALIGNMENT:
15011       switch (val)
15012         {
15013         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15014         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15015         }
15016       break;
15017
15018     case V850_NOTE_DATA_SIZE:
15019       switch (val)
15020         {
15021         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15022         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15023         }
15024       break;
15025
15026     case V850_NOTE_FPU_INFO:
15027       switch (val)
15028         {
15029         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15030         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15031         }
15032       break;
15033
15034     case V850_NOTE_MMU_INFO:
15035     case V850_NOTE_CACHE_INFO:
15036     case V850_NOTE_SIMD_INFO:
15037       if (val == EF_RH850_SIMD)
15038         {
15039           printf (_("yes\n"));
15040           return 1;
15041         }
15042       break;
15043
15044     default:
15045       /* An 'unknown note type' message will already have been displayed.  */
15046       break;
15047     }
15048
15049   printf (_("unknown value: %x\n"), val);
15050   return 0;
15051 }
15052
15053 static const char *
15054 get_netbsd_elfcore_note_type (unsigned e_type)
15055 {
15056   static char buff[64];
15057
15058   if (e_type == NT_NETBSDCORE_PROCINFO)
15059     {
15060       /* NetBSD core "procinfo" structure.  */
15061       return _("NetBSD procinfo structure");
15062     }
15063
15064   /* As of Jan 2002 there are no other machine-independent notes
15065      defined for NetBSD core files.  If the note type is less
15066      than the start of the machine-dependent note types, we don't
15067      understand it.  */
15068
15069   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15070     {
15071       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15072       return buff;
15073     }
15074
15075   switch (elf_header.e_machine)
15076     {
15077     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15078        and PT_GETFPREGS == mach+2.  */
15079
15080     case EM_OLD_ALPHA:
15081     case EM_ALPHA:
15082     case EM_SPARC:
15083     case EM_SPARC32PLUS:
15084     case EM_SPARCV9:
15085       switch (e_type)
15086         {
15087         case NT_NETBSDCORE_FIRSTMACH + 0:
15088           return _("PT_GETREGS (reg structure)");
15089         case NT_NETBSDCORE_FIRSTMACH + 2:
15090           return _("PT_GETFPREGS (fpreg structure)");
15091         default:
15092           break;
15093         }
15094       break;
15095
15096     /* On all other arch's, PT_GETREGS == mach+1 and
15097        PT_GETFPREGS == mach+3.  */
15098     default:
15099       switch (e_type)
15100         {
15101         case NT_NETBSDCORE_FIRSTMACH + 1:
15102           return _("PT_GETREGS (reg structure)");
15103         case NT_NETBSDCORE_FIRSTMACH + 3:
15104           return _("PT_GETFPREGS (fpreg structure)");
15105         default:
15106           break;
15107         }
15108     }
15109
15110   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15111             e_type - NT_NETBSDCORE_FIRSTMACH);
15112   return buff;
15113 }
15114
15115 static const char *
15116 get_stapsdt_note_type (unsigned e_type)
15117 {
15118   static char buff[64];
15119
15120   switch (e_type)
15121     {
15122     case NT_STAPSDT:
15123       return _("NT_STAPSDT (SystemTap probe descriptors)");
15124
15125     default:
15126       break;
15127     }
15128
15129   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15130   return buff;
15131 }
15132
15133 static int
15134 print_stapsdt_note (Elf_Internal_Note *pnote)
15135 {
15136   int addr_size = is_32bit_elf ? 4 : 8;
15137   char *data = pnote->descdata;
15138   char *data_end = pnote->descdata + pnote->descsz;
15139   bfd_vma pc, base_addr, semaphore;
15140   char *provider, *probe, *arg_fmt;
15141
15142   pc = byte_get ((unsigned char *) data, addr_size);
15143   data += addr_size;
15144   base_addr = byte_get ((unsigned char *) data, addr_size);
15145   data += addr_size;
15146   semaphore = byte_get ((unsigned char *) data, addr_size);
15147   data += addr_size;
15148
15149   provider = data;
15150   data += strlen (data) + 1;
15151   probe = data;
15152   data += strlen (data) + 1;
15153   arg_fmt = data;
15154   data += strlen (data) + 1;
15155
15156   printf (_("    Provider: %s\n"), provider);
15157   printf (_("    Name: %s\n"), probe);
15158   printf (_("    Location: "));
15159   print_vma (pc, FULL_HEX);
15160   printf (_(", Base: "));
15161   print_vma (base_addr, FULL_HEX);
15162   printf (_(", Semaphore: "));
15163   print_vma (semaphore, FULL_HEX);
15164   printf ("\n");
15165   printf (_("    Arguments: %s\n"), arg_fmt);
15166
15167   return data == data_end;
15168 }
15169
15170 static const char *
15171 get_ia64_vms_note_type (unsigned e_type)
15172 {
15173   static char buff[64];
15174
15175   switch (e_type)
15176     {
15177     case NT_VMS_MHD:
15178       return _("NT_VMS_MHD (module header)");
15179     case NT_VMS_LNM:
15180       return _("NT_VMS_LNM (language name)");
15181     case NT_VMS_SRC:
15182       return _("NT_VMS_SRC (source files)");
15183     case NT_VMS_TITLE:
15184       return "NT_VMS_TITLE";
15185     case NT_VMS_EIDC:
15186       return _("NT_VMS_EIDC (consistency check)");
15187     case NT_VMS_FPMODE:
15188       return _("NT_VMS_FPMODE (FP mode)");
15189     case NT_VMS_LINKTIME:
15190       return "NT_VMS_LINKTIME";
15191     case NT_VMS_IMGNAM:
15192       return _("NT_VMS_IMGNAM (image name)");
15193     case NT_VMS_IMGID:
15194       return _("NT_VMS_IMGID (image id)");
15195     case NT_VMS_LINKID:
15196       return _("NT_VMS_LINKID (link id)");
15197     case NT_VMS_IMGBID:
15198       return _("NT_VMS_IMGBID (build id)");
15199     case NT_VMS_GSTNAM:
15200       return _("NT_VMS_GSTNAM (sym table name)");
15201     case NT_VMS_ORIG_DYN:
15202       return "NT_VMS_ORIG_DYN";
15203     case NT_VMS_PATCHTIME:
15204       return "NT_VMS_PATCHTIME";
15205     default:
15206       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15207       return buff;
15208     }
15209 }
15210
15211 static int
15212 print_ia64_vms_note (Elf_Internal_Note * pnote)
15213 {
15214   switch (pnote->type)
15215     {
15216     case NT_VMS_MHD:
15217       if (pnote->descsz > 36)
15218         {
15219           size_t l = strlen (pnote->descdata + 34);
15220           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15221           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15222           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15223           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15224         }
15225       else
15226         printf (_("    Invalid size\n"));
15227       break;
15228     case NT_VMS_LNM:
15229       printf (_("   Language: %s\n"), pnote->descdata);
15230       break;
15231 #ifdef BFD64
15232     case NT_VMS_FPMODE:
15233       printf (_("   Floating Point mode: "));
15234       printf ("0x%016" BFD_VMA_FMT "x\n",
15235               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15236       break;
15237     case NT_VMS_LINKTIME:
15238       printf (_("   Link time: "));
15239       print_vms_time
15240         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15241       printf ("\n");
15242       break;
15243     case NT_VMS_PATCHTIME:
15244       printf (_("   Patch time: "));
15245       print_vms_time
15246         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15247       printf ("\n");
15248       break;
15249     case NT_VMS_ORIG_DYN:
15250       printf (_("   Major id: %u,  minor id: %u\n"),
15251               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15252               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15253       printf (_("   Last modified  : "));
15254       print_vms_time
15255         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15256       printf (_("\n   Link flags  : "));
15257       printf ("0x%016" BFD_VMA_FMT "x\n",
15258               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15259       printf (_("   Header flags: 0x%08x\n"),
15260               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15261       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15262       break;
15263 #endif
15264     case NT_VMS_IMGNAM:
15265       printf (_("    Image name: %s\n"), pnote->descdata);
15266       break;
15267     case NT_VMS_GSTNAM:
15268       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15269       break;
15270     case NT_VMS_IMGID:
15271       printf (_("    Image id: %s\n"), pnote->descdata);
15272       break;
15273     case NT_VMS_LINKID:
15274       printf (_("    Linker id: %s\n"), pnote->descdata);
15275       break;
15276     default:
15277       break;
15278     }
15279   return 1;
15280 }
15281
15282 /* Note that by the ELF standard, the name field is already null byte
15283    terminated, and namesz includes the terminating null byte.
15284    I.E. the value of namesz for the name "FSF" is 4.
15285
15286    If the value of namesz is zero, there is no name present.  */
15287 static int
15288 process_note (Elf_Internal_Note * pnote)
15289 {
15290   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15291   const char * nt;
15292
15293   if (pnote->namesz == 0)
15294     /* If there is no note name, then use the default set of
15295        note type strings.  */
15296     nt = get_note_type (pnote->type);
15297
15298   else if (const_strneq (pnote->namedata, "GNU"))
15299     /* GNU-specific object file notes.  */
15300     nt = get_gnu_elf_note_type (pnote->type);
15301
15302   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15303     /* NetBSD-specific core file notes.  */
15304     nt = get_netbsd_elfcore_note_type (pnote->type);
15305
15306   else if (strneq (pnote->namedata, "SPU/", 4))
15307     {
15308       /* SPU-specific core file notes.  */
15309       nt = pnote->namedata + 4;
15310       name = "SPU";
15311     }
15312
15313   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15314     /* VMS/ia64-specific file notes.  */
15315     nt = get_ia64_vms_note_type (pnote->type);
15316
15317   else if (const_strneq (pnote->namedata, "stapsdt"))
15318     nt = get_stapsdt_note_type (pnote->type);
15319
15320   else
15321     /* Don't recognize this note name; just use the default set of
15322        note type strings.  */
15323     nt = get_note_type (pnote->type);
15324
15325   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15326
15327   if (const_strneq (pnote->namedata, "IPF/VMS"))
15328     return print_ia64_vms_note (pnote);
15329   else if (const_strneq (pnote->namedata, "GNU"))
15330     return print_gnu_note (pnote);
15331   else if (const_strneq (pnote->namedata, "stapsdt"))
15332     return print_stapsdt_note (pnote);
15333   else if (const_strneq (pnote->namedata, "CORE"))
15334     return print_core_note (pnote);
15335   else
15336     return 1;
15337 }
15338
15339
15340 static int
15341 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15342 {
15343   Elf_External_Note * pnotes;
15344   Elf_External_Note * external;
15345   char * end;
15346   int res = 1;
15347
15348   if (length <= 0)
15349     return 0;
15350
15351   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15352                                            _("notes"));
15353   if (pnotes == NULL)
15354     return 0;
15355
15356   external = pnotes;
15357
15358   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15359           (unsigned long) offset, (unsigned long) length);
15360   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15361
15362   end = (char *) pnotes + length;
15363   while ((char *) external < end)
15364     {
15365       Elf_Internal_Note inote;
15366       size_t min_notesz;
15367       char *next;
15368       char * temp = NULL;
15369       size_t data_remaining = end - (char *) external;
15370
15371       if (!is_ia64_vms ())
15372         {
15373           /* PR binutils/15191
15374              Make sure that there is enough data to read.  */
15375           min_notesz = offsetof (Elf_External_Note, name);
15376           if (data_remaining < min_notesz)
15377             {
15378               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15379                     (int) data_remaining);
15380               break;
15381             }
15382           inote.type     = BYTE_GET (external->type);
15383           inote.namesz   = BYTE_GET (external->namesz);
15384           inote.namedata = external->name;
15385           inote.descsz   = BYTE_GET (external->descsz);
15386           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15387           /* PR 17531: file: 3443835e.  */
15388           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15389             {
15390               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15391               inote.descdata = inote.namedata;
15392               inote.namesz   = 0;
15393             }
15394
15395           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15396           next = inote.descdata + align_power (inote.descsz, 2);
15397         }
15398       else
15399         {
15400           Elf64_External_VMS_Note *vms_external;
15401
15402           /* PR binutils/15191
15403              Make sure that there is enough data to read.  */
15404           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15405           if (data_remaining < min_notesz)
15406             {
15407               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15408                     (int) data_remaining);
15409               break;
15410             }
15411
15412           vms_external = (Elf64_External_VMS_Note *) external;
15413           inote.type     = BYTE_GET (vms_external->type);
15414           inote.namesz   = BYTE_GET (vms_external->namesz);
15415           inote.namedata = vms_external->name;
15416           inote.descsz   = BYTE_GET (vms_external->descsz);
15417           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15418           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15419           next = inote.descdata + align_power (inote.descsz, 3);
15420         }
15421
15422       if (inote.descdata < (char *) external + min_notesz
15423           || next < (char *) external + min_notesz
15424           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15425           || inote.namedata + inote.namesz < inote.namedata
15426           || inote.descdata + inote.descsz < inote.descdata
15427           || data_remaining < (size_t)(next - (char *) external))
15428         {
15429           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15430                 (unsigned long) ((char *) external - (char *) pnotes));
15431           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15432                 inote.type, inote.namesz, inote.descsz);
15433           break;
15434         }
15435
15436       external = (Elf_External_Note *) next;
15437
15438       /* Verify that name is null terminated.  It appears that at least
15439          one version of Linux (RedHat 6.0) generates corefiles that don't
15440          comply with the ELF spec by failing to include the null byte in
15441          namesz.  */
15442       if (inote.namedata[inote.namesz - 1] != '\0')
15443         {
15444           temp = (char *) malloc (inote.namesz + 1);
15445           if (temp == NULL)
15446             {
15447               error (_("Out of memory allocating space for inote name\n"));
15448               res = 0;
15449               break;
15450             }
15451
15452           strncpy (temp, inote.namedata, inote.namesz);
15453           temp[inote.namesz] = 0;
15454
15455           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15456           inote.namedata = temp;
15457         }
15458
15459       res &= process_note (& inote);
15460
15461       if (temp != NULL)
15462         {
15463           free (temp);
15464           temp = NULL;
15465         }
15466     }
15467
15468   free (pnotes);
15469
15470   return res;
15471 }
15472
15473 static int
15474 process_corefile_note_segments (FILE * file)
15475 {
15476   Elf_Internal_Phdr * segment;
15477   unsigned int i;
15478   int res = 1;
15479
15480   if (! get_program_headers (file))
15481       return 0;
15482
15483   for (i = 0, segment = program_headers;
15484        i < elf_header.e_phnum;
15485        i++, segment++)
15486     {
15487       if (segment->p_type == PT_NOTE)
15488         res &= process_corefile_note_segment (file,
15489                                               (bfd_vma) segment->p_offset,
15490                                               (bfd_vma) segment->p_filesz);
15491     }
15492
15493   return res;
15494 }
15495
15496 static int
15497 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15498 {
15499   Elf_External_Note * pnotes;
15500   Elf_External_Note * external;
15501   char * end;
15502   int res = 1;
15503
15504   if (length <= 0)
15505     return 0;
15506
15507   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15508                                            _("v850 notes"));
15509   if (pnotes == NULL)
15510     return 0;
15511
15512   external = pnotes;
15513   end = (char*) pnotes + length;
15514
15515   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15516           (unsigned long) offset, (unsigned long) length);
15517
15518   while ((char *) external + sizeof (Elf_External_Note) < end)
15519     {
15520       Elf_External_Note * next;
15521       Elf_Internal_Note inote;
15522
15523       inote.type     = BYTE_GET (external->type);
15524       inote.namesz   = BYTE_GET (external->namesz);
15525       inote.namedata = external->name;
15526       inote.descsz   = BYTE_GET (external->descsz);
15527       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15528       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15529
15530       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15531         {
15532           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15533           inote.descdata = inote.namedata;
15534           inote.namesz   = 0;
15535         }
15536
15537       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15538
15539       if (   ((char *) next > end)
15540           || ((char *) next <  (char *) pnotes))
15541         {
15542           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15543                 (unsigned long) ((char *) external - (char *) pnotes));
15544           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15545                 inote.type, inote.namesz, inote.descsz);
15546           break;
15547         }
15548
15549       external = next;
15550
15551       /* Prevent out-of-bounds indexing.  */
15552       if (   inote.namedata + inote.namesz > end
15553           || inote.namedata + inote.namesz < inote.namedata)
15554         {
15555           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15556                 (unsigned long) ((char *) external - (char *) pnotes));
15557           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15558                 inote.type, inote.namesz, inote.descsz);
15559           break;
15560         }
15561
15562       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15563
15564       if (! print_v850_note (& inote))
15565         {
15566           res = 0;
15567           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15568                   inote.namesz, inote.descsz);
15569         }
15570     }
15571
15572   free (pnotes);
15573
15574   return res;
15575 }
15576
15577 static int
15578 process_note_sections (FILE * file)
15579 {
15580   Elf_Internal_Shdr * section;
15581   unsigned long i;
15582   int n = 0;
15583   int res = 1;
15584
15585   for (i = 0, section = section_headers;
15586        i < elf_header.e_shnum && section != NULL;
15587        i++, section++)
15588     {
15589       if (section->sh_type == SHT_NOTE)
15590         {
15591           res &= process_corefile_note_segment (file,
15592                                                 (bfd_vma) section->sh_offset,
15593                                                 (bfd_vma) section->sh_size);
15594           n++;
15595         }
15596
15597       if ((   elf_header.e_machine == EM_V800
15598            || elf_header.e_machine == EM_V850
15599            || elf_header.e_machine == EM_CYGNUS_V850)
15600           && section->sh_type == SHT_RENESAS_INFO)
15601         {
15602           res &= process_v850_notes (file,
15603                                      (bfd_vma) section->sh_offset,
15604                                      (bfd_vma) section->sh_size);
15605           n++;
15606         }
15607     }
15608
15609   if (n == 0)
15610     /* Try processing NOTE segments instead.  */
15611     return process_corefile_note_segments (file);
15612
15613   return res;
15614 }
15615
15616 static int
15617 process_notes (FILE * file)
15618 {
15619   /* If we have not been asked to display the notes then do nothing.  */
15620   if (! do_notes)
15621     return 1;
15622
15623   if (elf_header.e_type != ET_CORE)
15624     return process_note_sections (file);
15625
15626   /* No program headers means no NOTE segment.  */
15627   if (elf_header.e_phnum > 0)
15628     return process_corefile_note_segments (file);
15629
15630   printf (_("No note segments present in the core file.\n"));
15631   return 1;
15632 }
15633
15634 static int
15635 process_arch_specific (FILE * file)
15636 {
15637   if (! do_arch)
15638     return 1;
15639
15640   switch (elf_header.e_machine)
15641     {
15642     case EM_ARM:
15643       return process_arm_specific (file);
15644     case EM_MIPS:
15645     case EM_MIPS_RS3_LE:
15646       return process_mips_specific (file);
15647       break;
15648     case EM_NDS32:
15649       return process_nds32_specific (file);
15650       break;
15651     case EM_PPC:
15652       return process_power_specific (file);
15653       break;
15654     case EM_S390:
15655     case EM_S390_OLD:
15656       return process_s390_specific (file);
15657       break;
15658     case EM_SPARC:
15659     case EM_SPARC32PLUS:
15660     case EM_SPARCV9:
15661       return process_sparc_specific (file);
15662       break;
15663     case EM_TI_C6000:
15664       return process_tic6x_specific (file);
15665       break;
15666     case EM_MSP430:
15667       return process_msp430x_specific (file);
15668     default:
15669       break;
15670     }
15671   return 1;
15672 }
15673
15674 static int
15675 get_file_header (FILE * file)
15676 {
15677   /* Read in the identity array.  */
15678   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15679     return 0;
15680
15681   /* Determine how to read the rest of the header.  */
15682   switch (elf_header.e_ident[EI_DATA])
15683     {
15684     default: /* fall through */
15685     case ELFDATANONE: /* fall through */
15686     case ELFDATA2LSB:
15687       byte_get = byte_get_little_endian;
15688       byte_put = byte_put_little_endian;
15689       break;
15690     case ELFDATA2MSB:
15691       byte_get = byte_get_big_endian;
15692       byte_put = byte_put_big_endian;
15693       break;
15694     }
15695
15696   /* For now we only support 32 bit and 64 bit ELF files.  */
15697   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15698
15699   /* Read in the rest of the header.  */
15700   if (is_32bit_elf)
15701     {
15702       Elf32_External_Ehdr ehdr32;
15703
15704       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15705         return 0;
15706
15707       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15708       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15709       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15710       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15711       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15712       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15713       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15714       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15715       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15716       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15717       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15718       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15719       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15720     }
15721   else
15722     {
15723       Elf64_External_Ehdr ehdr64;
15724
15725       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15726          we will not be able to cope with the 64bit data found in
15727          64 ELF files.  Detect this now and abort before we start
15728          overwriting things.  */
15729       if (sizeof (bfd_vma) < 8)
15730         {
15731           error (_("This instance of readelf has been built without support for a\n\
15732 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15733           return 0;
15734         }
15735
15736       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15737         return 0;
15738
15739       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15740       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15741       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15742       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15743       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15744       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15745       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15746       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15747       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15748       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15749       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15750       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15751       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15752     }
15753
15754   if (elf_header.e_shoff)
15755     {
15756       /* There may be some extensions in the first section header.  Don't
15757          bomb if we can't read it.  */
15758       if (is_32bit_elf)
15759         get_32bit_section_headers (file, TRUE);
15760       else
15761         get_64bit_section_headers (file, TRUE);
15762     }
15763
15764   return 1;
15765 }
15766
15767 /* Process one ELF object file according to the command line options.
15768    This file may actually be stored in an archive.  The file is
15769    positioned at the start of the ELF object.  */
15770
15771 static int
15772 process_object (char * file_name, FILE * file)
15773 {
15774   unsigned int i;
15775
15776   if (! get_file_header (file))
15777     {
15778       error (_("%s: Failed to read file header\n"), file_name);
15779       return 1;
15780     }
15781
15782   /* Initialise per file variables.  */
15783   for (i = ARRAY_SIZE (version_info); i--;)
15784     version_info[i] = 0;
15785
15786   for (i = ARRAY_SIZE (dynamic_info); i--;)
15787     dynamic_info[i] = 0;
15788   dynamic_info_DT_GNU_HASH = 0;
15789
15790   /* Process the file.  */
15791   if (show_name)
15792     printf (_("\nFile: %s\n"), file_name);
15793
15794   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15795      Note we do this even if cmdline_dump_sects is empty because we
15796      must make sure that the dump_sets array is zeroed out before each
15797      object file is processed.  */
15798   if (num_dump_sects > num_cmdline_dump_sects)
15799     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15800
15801   if (num_cmdline_dump_sects > 0)
15802     {
15803       if (num_dump_sects == 0)
15804         /* A sneaky way of allocating the dump_sects array.  */
15805         request_dump_bynumber (num_cmdline_dump_sects, 0);
15806
15807       assert (num_dump_sects >= num_cmdline_dump_sects);
15808       memcpy (dump_sects, cmdline_dump_sects,
15809               num_cmdline_dump_sects * sizeof (* dump_sects));
15810     }
15811
15812   if (! process_file_header ())
15813     return 1;
15814
15815   if (! process_section_headers (file))
15816     {
15817       /* Without loaded section headers we cannot process lots of
15818          things.  */
15819       do_unwind = do_version = do_dump = do_arch = 0;
15820
15821       if (! do_using_dynamic)
15822         do_syms = do_dyn_syms = do_reloc = 0;
15823     }
15824
15825   if (! process_section_groups (file))
15826     {
15827       /* Without loaded section groups we cannot process unwind.  */
15828       do_unwind = 0;
15829     }
15830
15831   if (process_program_headers (file))
15832     process_dynamic_section (file);
15833
15834   process_relocs (file);
15835
15836   process_unwind (file);
15837
15838   process_symbol_table (file);
15839
15840   process_syminfo (file);
15841
15842   process_version_sections (file);
15843
15844   process_section_contents (file);
15845
15846   process_notes (file);
15847
15848   process_gnu_liblist (file);
15849
15850   process_arch_specific (file);
15851
15852   if (program_headers)
15853     {
15854       free (program_headers);
15855       program_headers = NULL;
15856     }
15857
15858   if (section_headers)
15859     {
15860       free (section_headers);
15861       section_headers = NULL;
15862     }
15863
15864   if (string_table)
15865     {
15866       free (string_table);
15867       string_table = NULL;
15868       string_table_length = 0;
15869     }
15870
15871   if (dynamic_strings)
15872     {
15873       free (dynamic_strings);
15874       dynamic_strings = NULL;
15875       dynamic_strings_length = 0;
15876     }
15877
15878   if (dynamic_symbols)
15879     {
15880       free (dynamic_symbols);
15881       dynamic_symbols = NULL;
15882       num_dynamic_syms = 0;
15883     }
15884
15885   if (dynamic_syminfo)
15886     {
15887       free (dynamic_syminfo);
15888       dynamic_syminfo = NULL;
15889     }
15890
15891   if (dynamic_section)
15892     {
15893       free (dynamic_section);
15894       dynamic_section = NULL;
15895     }
15896
15897   if (section_headers_groups)
15898     {
15899       free (section_headers_groups);
15900       section_headers_groups = NULL;
15901     }
15902
15903   if (section_groups)
15904     {
15905       struct group_list * g;
15906       struct group_list * next;
15907
15908       for (i = 0; i < group_count; i++)
15909         {
15910           for (g = section_groups [i].root; g != NULL; g = next)
15911             {
15912               next = g->next;
15913               free (g);
15914             }
15915         }
15916
15917       free (section_groups);
15918       section_groups = NULL;
15919     }
15920
15921   free_debug_memory ();
15922
15923   return 0;
15924 }
15925
15926 /* Process an ELF archive.
15927    On entry the file is positioned just after the ARMAG string.  */
15928
15929 static int
15930 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15931 {
15932   struct archive_info arch;
15933   struct archive_info nested_arch;
15934   size_t got;
15935   int ret;
15936
15937   show_name = 1;
15938
15939   /* The ARCH structure is used to hold information about this archive.  */
15940   arch.file_name = NULL;
15941   arch.file = NULL;
15942   arch.index_array = NULL;
15943   arch.sym_table = NULL;
15944   arch.longnames = NULL;
15945
15946   /* The NESTED_ARCH structure is used as a single-item cache of information
15947      about a nested archive (when members of a thin archive reside within
15948      another regular archive file).  */
15949   nested_arch.file_name = NULL;
15950   nested_arch.file = NULL;
15951   nested_arch.index_array = NULL;
15952   nested_arch.sym_table = NULL;
15953   nested_arch.longnames = NULL;
15954
15955   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15956     {
15957       ret = 1;
15958       goto out;
15959     }
15960
15961   if (do_archive_index)
15962     {
15963       if (arch.sym_table == NULL)
15964         error (_("%s: unable to dump the index as none was found\n"), file_name);
15965       else
15966         {
15967           unsigned long i, l;
15968           unsigned long current_pos;
15969
15970           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15971                   file_name, (unsigned long) arch.index_num, arch.sym_size);
15972           current_pos = ftell (file);
15973
15974           for (i = l = 0; i < arch.index_num; i++)
15975             {
15976               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15977                 {
15978                   char * member_name;
15979
15980                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15981
15982                   if (member_name != NULL)
15983                     {
15984                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15985
15986                       if (qualified_name != NULL)
15987                         {
15988                           printf (_("Contents of binary %s at offset "), qualified_name);
15989                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
15990                           putchar ('\n');
15991                           free (qualified_name);
15992                         }
15993                     }
15994                 }
15995
15996               if (l >= arch.sym_size)
15997                 {
15998                   error (_("%s: end of the symbol table reached before the end of the index\n"),
15999                          file_name);
16000                   break;
16001                 }
16002               /* PR 17531: file: 0b6630b2.  */
16003               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16004               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16005             }
16006
16007           if (arch.uses_64bit_indicies)
16008             l = (l + 7) & ~ 7;
16009           else
16010             l += l & 1;
16011
16012           if (l < arch.sym_size)
16013             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16014                    file_name, arch.sym_size - l);
16015
16016           if (fseek (file, current_pos, SEEK_SET) != 0)
16017             {
16018               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16019               ret = 1;
16020               goto out;
16021             }
16022         }
16023
16024       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16025           && !do_segments && !do_header && !do_dump && !do_version
16026           && !do_histogram && !do_debugging && !do_arch && !do_notes
16027           && !do_section_groups && !do_dyn_syms)
16028         {
16029           ret = 0; /* Archive index only.  */
16030           goto out;
16031         }
16032     }
16033
16034   ret = 0;
16035
16036   while (1)
16037     {
16038       char * name;
16039       size_t namelen;
16040       char * qualified_name;
16041
16042       /* Read the next archive header.  */
16043       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16044         {
16045           error (_("%s: failed to seek to next archive header\n"), file_name);
16046           return 1;
16047         }
16048       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16049       if (got != sizeof arch.arhdr)
16050         {
16051           if (got == 0)
16052             break;
16053           error (_("%s: failed to read archive header\n"), file_name);
16054           ret = 1;
16055           break;
16056         }
16057       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16058         {
16059           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16060           ret = 1;
16061           break;
16062         }
16063
16064       arch.next_arhdr_offset += sizeof arch.arhdr;
16065
16066       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16067       if (archive_file_size & 01)
16068         ++archive_file_size;
16069
16070       name = get_archive_member_name (&arch, &nested_arch);
16071       if (name == NULL)
16072         {
16073           error (_("%s: bad archive file name\n"), file_name);
16074           ret = 1;
16075           break;
16076         }
16077       namelen = strlen (name);
16078
16079       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16080       if (qualified_name == NULL)
16081         {
16082           error (_("%s: bad archive file name\n"), file_name);
16083           ret = 1;
16084           break;
16085         }
16086
16087       if (is_thin_archive && arch.nested_member_origin == 0)
16088         {
16089           /* This is a proxy for an external member of a thin archive.  */
16090           FILE * member_file;
16091           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16092           if (member_file_name == NULL)
16093             {
16094               ret = 1;
16095               break;
16096             }
16097
16098           member_file = fopen (member_file_name, "rb");
16099           if (member_file == NULL)
16100             {
16101               error (_("Input file '%s' is not readable.\n"), member_file_name);
16102               free (member_file_name);
16103               ret = 1;
16104               break;
16105             }
16106
16107           archive_file_offset = arch.nested_member_origin;
16108
16109           ret |= process_object (qualified_name, member_file);
16110
16111           fclose (member_file);
16112           free (member_file_name);
16113         }
16114       else if (is_thin_archive)
16115         {
16116           /* PR 15140: Allow for corrupt thin archives.  */
16117           if (nested_arch.file == NULL)
16118             {
16119               error (_("%s: contains corrupt thin archive: %s\n"),
16120                      file_name, name);
16121               ret = 1;
16122               break;
16123             }
16124
16125           /* This is a proxy for a member of a nested archive.  */
16126           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16127
16128           /* The nested archive file will have been opened and setup by
16129              get_archive_member_name.  */
16130           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16131             {
16132               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16133               ret = 1;
16134               break;
16135             }
16136
16137           ret |= process_object (qualified_name, nested_arch.file);
16138         }
16139       else
16140         {
16141           archive_file_offset = arch.next_arhdr_offset;
16142           arch.next_arhdr_offset += archive_file_size;
16143
16144           ret |= process_object (qualified_name, file);
16145         }
16146
16147       if (dump_sects != NULL)
16148         {
16149           free (dump_sects);
16150           dump_sects = NULL;
16151           num_dump_sects = 0;
16152         }
16153
16154       free (qualified_name);
16155     }
16156
16157  out:
16158   if (nested_arch.file != NULL)
16159     fclose (nested_arch.file);
16160   release_archive (&nested_arch);
16161   release_archive (&arch);
16162
16163   return ret;
16164 }
16165
16166 static int
16167 process_file (char * file_name)
16168 {
16169   FILE * file;
16170   struct stat statbuf;
16171   char armag[SARMAG];
16172   int ret;
16173
16174   if (stat (file_name, &statbuf) < 0)
16175     {
16176       if (errno == ENOENT)
16177         error (_("'%s': No such file\n"), file_name);
16178       else
16179         error (_("Could not locate '%s'.  System error message: %s\n"),
16180                file_name, strerror (errno));
16181       return 1;
16182     }
16183
16184   if (! S_ISREG (statbuf.st_mode))
16185     {
16186       error (_("'%s' is not an ordinary file\n"), file_name);
16187       return 1;
16188     }
16189
16190   file = fopen (file_name, "rb");
16191   if (file == NULL)
16192     {
16193       error (_("Input file '%s' is not readable.\n"), file_name);
16194       return 1;
16195     }
16196
16197   if (fread (armag, SARMAG, 1, file) != 1)
16198     {
16199       error (_("%s: Failed to read file's magic number\n"), file_name);
16200       fclose (file);
16201       return 1;
16202     }
16203
16204   current_file_size = (bfd_size_type) statbuf.st_size;
16205
16206   if (memcmp (armag, ARMAG, SARMAG) == 0)
16207     ret = process_archive (file_name, file, FALSE);
16208   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16209     ret = process_archive (file_name, file, TRUE);
16210   else
16211     {
16212       if (do_archive_index)
16213         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16214                file_name);
16215
16216       rewind (file);
16217       archive_file_size = archive_file_offset = 0;
16218       ret = process_object (file_name, file);
16219     }
16220
16221   fclose (file);
16222
16223   current_file_size = 0;
16224   return ret;
16225 }
16226
16227 #ifdef SUPPORT_DISASSEMBLY
16228 /* Needed by the i386 disassembler.  For extra credit, someone could
16229    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16230    symbols.  */
16231
16232 void
16233 print_address (unsigned int addr, FILE * outfile)
16234 {
16235   fprintf (outfile,"0x%8.8x", addr);
16236 }
16237
16238 /* Needed by the i386 disassembler.  */
16239 void
16240 db_task_printsym (unsigned int addr)
16241 {
16242   print_address (addr, stderr);
16243 }
16244 #endif
16245
16246 int
16247 main (int argc, char ** argv)
16248 {
16249   int err;
16250
16251 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16252   setlocale (LC_MESSAGES, "");
16253 #endif
16254 #if defined (HAVE_SETLOCALE)
16255   setlocale (LC_CTYPE, "");
16256 #endif
16257   bindtextdomain (PACKAGE, LOCALEDIR);
16258   textdomain (PACKAGE);
16259
16260   expandargv (&argc, &argv);
16261
16262   parse_args (argc, argv);
16263
16264   if (num_dump_sects > 0)
16265     {
16266       /* Make a copy of the dump_sects array.  */
16267       cmdline_dump_sects = (dump_type *)
16268           malloc (num_dump_sects * sizeof (* dump_sects));
16269       if (cmdline_dump_sects == NULL)
16270         error (_("Out of memory allocating dump request table.\n"));
16271       else
16272         {
16273           memcpy (cmdline_dump_sects, dump_sects,
16274                   num_dump_sects * sizeof (* dump_sects));
16275           num_cmdline_dump_sects = num_dump_sects;
16276         }
16277     }
16278
16279   if (optind < (argc - 1))
16280     show_name = 1;
16281   else if (optind >= argc)
16282     {
16283       warn (_("Nothing to do.\n"));
16284       usage (stderr);
16285     }
16286
16287   err = 0;
16288   while (optind < argc)
16289     err |= process_file (argv[optind++]);
16290
16291   if (dump_sects != NULL)
16292     free (dump_sects);
16293   if (cmdline_dump_sects != NULL)
16294     free (cmdline_dump_sects);
16295
16296   return err;
16297 }