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_IAMCU:
 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_IAMCU:
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_IAMCU:              return "Intel MCU";
2095     case EM_860:                return "Intel 80860";
2096     case EM_MIPS:               return "MIPS R3000";
2097     case EM_S370:               return "IBM System/370";
2098     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2099     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2100     case EM_PARISC:             return "HPPA";
2101     case EM_PPC_OLD:            return "Power PC (old)";
2102     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2103     case EM_960:                return "Intel 90860";
2104     case EM_PPC:                return "PowerPC";
2105     case EM_PPC64:              return "PowerPC64";
2106     case EM_FR20:               return "Fujitsu FR20";
2107     case EM_FT32:               return "FTDI FT32";
2108     case EM_RH32:               return "TRW RH32";
2109     case EM_MCORE:              return "MCORE";
2110     case EM_ARM:                return "ARM";
2111     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2112     case EM_SH:                 return "Renesas / SuperH SH";
2113     case EM_SPARCV9:            return "Sparc v9";
2114     case EM_TRICORE:            return "Siemens Tricore";
2115     case EM_ARC:                return "ARC";
2116     case EM_H8_300:             return "Renesas H8/300";
2117     case EM_H8_300H:            return "Renesas H8/300H";
2118     case EM_H8S:                return "Renesas H8S";
2119     case EM_H8_500:             return "Renesas H8/500";
2120     case EM_IA_64:              return "Intel IA-64";
2121     case EM_MIPS_X:             return "Stanford MIPS-X";
2122     case EM_COLDFIRE:           return "Motorola Coldfire";
2123     case EM_ALPHA:              return "Alpha";
2124     case EM_CYGNUS_D10V:
2125     case EM_D10V:               return "d10v";
2126     case EM_CYGNUS_D30V:
2127     case EM_D30V:               return "d30v";
2128     case EM_CYGNUS_M32R:
2129     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2130     case EM_CYGNUS_V850:
2131     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2132     case EM_V850:               return "Renesas V850";
2133     case EM_CYGNUS_MN10300:
2134     case EM_MN10300:            return "mn10300";
2135     case EM_CYGNUS_MN10200:
2136     case EM_MN10200:            return "mn10200";
2137     case EM_MOXIE:              return "Moxie";
2138     case EM_CYGNUS_FR30:
2139     case EM_FR30:               return "Fujitsu FR30";
2140     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2141     case EM_PJ_OLD:
2142     case EM_PJ:                 return "picoJava";
2143     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2144     case EM_PCP:                return "Siemens PCP";
2145     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2146     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2147     case EM_STARCORE:           return "Motorola Star*Core processor";
2148     case EM_ME16:               return "Toyota ME16 processor";
2149     case EM_ST100:              return "STMicroelectronics ST100 processor";
2150     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2151     case EM_PDSP:               return "Sony DSP processor";
2152     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2153     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2154     case EM_FX66:               return "Siemens FX66 microcontroller";
2155     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2156     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2157     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2158     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2159     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2160     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2161     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2162     case EM_SVX:                return "Silicon Graphics SVx";
2163     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2164     case EM_VAX:                return "Digital VAX";
2165     case EM_VISIUM:             return "CDS VISIUMcore processor";
2166     case EM_AVR_OLD:
2167     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2168     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2169     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2170     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2171     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2172     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2173     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2174     case EM_PRISM:              return "Vitesse Prism";
2175     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2176     case EM_L1OM:               return "Intel L1OM";
2177     case EM_K1OM:               return "Intel K1OM";
2178     case EM_S390_OLD:
2179     case EM_S390:               return "IBM S/390";
2180     case EM_SCORE:              return "SUNPLUS S+Core";
2181     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2182     case EM_OR1K:               return "OpenRISC 1000";
2183     case EM_ARC_A5:             return "ARC International ARCompact processor";
2184     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2185     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2186     case EM_DLX:                return "OpenDLX";
2187     case EM_IP2K_OLD:
2188     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2189     case EM_IQ2000:             return "Vitesse IQ2000";
2190     case EM_XTENSA_OLD:
2191     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2192     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2193     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2194     case EM_NS32K:              return "National Semiconductor 32000 series";
2195     case EM_TPC:                return "Tenor Network TPC processor";
2196     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2197     case EM_MAX:                return "MAX Processor";
2198     case EM_CR:                 return "National Semiconductor CompactRISC";
2199     case EM_F2MC16:             return "Fujitsu F2MC16";
2200     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2201     case EM_LATTICEMICO32:      return "Lattice Mico32";
2202     case EM_M32C_OLD:
2203     case EM_M32C:               return "Renesas M32c";
2204     case EM_MT:                 return "Morpho Techologies MT processor";
2205     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2206     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2207     case EM_SEP:                return "Sharp embedded microprocessor";
2208     case EM_ARCA:               return "Arca RISC microprocessor";
2209     case EM_UNICORE:            return "Unicore";
2210     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2211     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2212     case EM_NIOS32:             return "Altera Nios";
2213     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2214     case EM_C166:
2215     case EM_XC16X:              return "Infineon Technologies xc16x";
2216     case EM_M16C:               return "Renesas M16C series microprocessors";
2217     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2218     case EM_CE:                 return "Freescale Communication Engine RISC core";
2219     case EM_TSK3000:            return "Altium TSK3000 core";
2220     case EM_RS08:               return "Freescale RS08 embedded processor";
2221     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2222     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2223     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2224     case EM_SE_C17:             return "Seiko Epson C17 family";
2225     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2226     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2227     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2228     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2229     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2230     case EM_R32C:               return "Renesas R32C series microprocessors";
2231     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2232     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2233     case EM_8051:               return "Intel 8051 and variants";
2234     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2235     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2236     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2237     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2238     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2239     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2240     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2241     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2242     case EM_CR16:
2243     case EM_MICROBLAZE:
2244     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2245     case EM_RL78:               return "Renesas RL78";
2246     case EM_RX:                 return "Renesas RX";
2247     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2248     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2249     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2250     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2251     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2252     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2253     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2254     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2255     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2256     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2257     case EM_CUDA:               return "NVIDIA CUDA architecture";
2258     case EM_XGATE:              return "Motorola XGATE embedded processor";
2259     default:
2260       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2261       return buff;
2262     }
2263 }
2264
2265 static void
2266 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2267 {
2268   unsigned eabi;
2269   int unknown = 0;
2270
2271   eabi = EF_ARM_EABI_VERSION (e_flags);
2272   e_flags &= ~ EF_ARM_EABIMASK;
2273
2274   /* Handle "generic" ARM flags.  */
2275   if (e_flags & EF_ARM_RELEXEC)
2276     {
2277       strcat (buf, ", relocatable executable");
2278       e_flags &= ~ EF_ARM_RELEXEC;
2279     }
2280
2281   /* Now handle EABI specific flags.  */
2282   switch (eabi)
2283     {
2284     default:
2285       strcat (buf, ", <unrecognized EABI>");
2286       if (e_flags)
2287         unknown = 1;
2288       break;
2289
2290     case EF_ARM_EABI_VER1:
2291       strcat (buf, ", Version1 EABI");
2292       while (e_flags)
2293         {
2294           unsigned flag;
2295
2296           /* Process flags one bit at a time.  */
2297           flag = e_flags & - e_flags;
2298           e_flags &= ~ flag;
2299
2300           switch (flag)
2301             {
2302             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2303               strcat (buf, ", sorted symbol tables");
2304               break;
2305
2306             default:
2307               unknown = 1;
2308               break;
2309             }
2310         }
2311       break;
2312
2313     case EF_ARM_EABI_VER2:
2314       strcat (buf, ", Version2 EABI");
2315       while (e_flags)
2316         {
2317           unsigned flag;
2318
2319           /* Process flags one bit at a time.  */
2320           flag = e_flags & - e_flags;
2321           e_flags &= ~ flag;
2322
2323           switch (flag)
2324             {
2325             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2326               strcat (buf, ", sorted symbol tables");
2327               break;
2328
2329             case EF_ARM_DYNSYMSUSESEGIDX:
2330               strcat (buf, ", dynamic symbols use segment index");
2331               break;
2332
2333             case EF_ARM_MAPSYMSFIRST:
2334               strcat (buf, ", mapping symbols precede others");
2335               break;
2336
2337             default:
2338               unknown = 1;
2339               break;
2340             }
2341         }
2342       break;
2343
2344     case EF_ARM_EABI_VER3:
2345       strcat (buf, ", Version3 EABI");
2346       break;
2347
2348     case EF_ARM_EABI_VER4:
2349       strcat (buf, ", Version4 EABI");
2350       while (e_flags)
2351         {
2352           unsigned flag;
2353
2354           /* Process flags one bit at a time.  */
2355           flag = e_flags & - e_flags;
2356           e_flags &= ~ flag;
2357
2358           switch (flag)
2359             {
2360             case EF_ARM_BE8:
2361               strcat (buf, ", BE8");
2362               break;
2363
2364             case EF_ARM_LE8:
2365               strcat (buf, ", LE8");
2366               break;
2367
2368             default:
2369               unknown = 1;
2370               break;
2371             }
2372       break;
2373         }
2374       break;
2375
2376     case EF_ARM_EABI_VER5:
2377       strcat (buf, ", Version5 EABI");
2378       while (e_flags)
2379         {
2380           unsigned flag;
2381
2382           /* Process flags one bit at a time.  */
2383           flag = e_flags & - e_flags;
2384           e_flags &= ~ flag;
2385
2386           switch (flag)
2387             {
2388             case EF_ARM_BE8:
2389               strcat (buf, ", BE8");
2390               break;
2391
2392             case EF_ARM_LE8:
2393               strcat (buf, ", LE8");
2394               break;
2395
2396             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2397               strcat (buf, ", soft-float ABI");
2398               break;
2399
2400             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2401               strcat (buf, ", hard-float ABI");
2402               break;
2403
2404             default:
2405               unknown = 1;
2406               break;
2407             }
2408         }
2409       break;
2410
2411     case EF_ARM_EABI_UNKNOWN:
2412       strcat (buf, ", GNU EABI");
2413       while (e_flags)
2414         {
2415           unsigned flag;
2416
2417           /* Process flags one bit at a time.  */
2418           flag = e_flags & - e_flags;
2419           e_flags &= ~ flag;
2420
2421           switch (flag)
2422             {
2423             case EF_ARM_INTERWORK:
2424               strcat (buf, ", interworking enabled");
2425               break;
2426
2427             case EF_ARM_APCS_26:
2428               strcat (buf, ", uses APCS/26");
2429               break;
2430
2431             case EF_ARM_APCS_FLOAT:
2432               strcat (buf, ", uses APCS/float");
2433               break;
2434
2435             case EF_ARM_PIC:
2436               strcat (buf, ", position independent");
2437               break;
2438
2439             case EF_ARM_ALIGN8:
2440               strcat (buf, ", 8 bit structure alignment");
2441               break;
2442
2443             case EF_ARM_NEW_ABI:
2444               strcat (buf, ", uses new ABI");
2445               break;
2446
2447             case EF_ARM_OLD_ABI:
2448               strcat (buf, ", uses old ABI");
2449               break;
2450
2451             case EF_ARM_SOFT_FLOAT:
2452               strcat (buf, ", software FP");
2453               break;
2454
2455             case EF_ARM_VFP_FLOAT:
2456               strcat (buf, ", VFP");
2457               break;
2458
2459             case EF_ARM_MAVERICK_FLOAT:
2460               strcat (buf, ", Maverick FP");
2461               break;
2462
2463             default:
2464               unknown = 1;
2465               break;
2466             }
2467         }
2468     }
2469
2470   if (unknown)
2471     strcat (buf,_(", <unknown>"));
2472 }
2473
2474 static void
2475 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2476 {
2477   --size; /* Leave space for null terminator.  */
2478
2479   switch (e_flags & EF_AVR_MACH)
2480     {
2481     case E_AVR_MACH_AVR1:
2482       strncat (buf, ", avr:1", size);
2483       break;
2484     case E_AVR_MACH_AVR2:
2485       strncat (buf, ", avr:2", size);
2486       break;
2487     case E_AVR_MACH_AVR25:
2488       strncat (buf, ", avr:25", size);
2489       break;
2490     case E_AVR_MACH_AVR3:
2491       strncat (buf, ", avr:3", size);
2492       break;
2493     case E_AVR_MACH_AVR31:
2494       strncat (buf, ", avr:31", size);
2495       break;
2496     case E_AVR_MACH_AVR35:
2497       strncat (buf, ", avr:35", size);
2498       break;
2499     case E_AVR_MACH_AVR4:
2500       strncat (buf, ", avr:4", size);
2501       break;
2502     case E_AVR_MACH_AVR5:
2503       strncat (buf, ", avr:5", size);
2504       break;
2505     case E_AVR_MACH_AVR51:
2506       strncat (buf, ", avr:51", size);
2507       break;
2508     case E_AVR_MACH_AVR6:
2509       strncat (buf, ", avr:6", size);
2510       break;
2511     case E_AVR_MACH_AVRTINY:
2512       strncat (buf, ", avr:100", size);
2513       break;
2514     case E_AVR_MACH_XMEGA1:
2515       strncat (buf, ", avr:101", size);
2516       break;
2517     case E_AVR_MACH_XMEGA2:
2518       strncat (buf, ", avr:102", size);
2519       break;
2520     case E_AVR_MACH_XMEGA3:
2521       strncat (buf, ", avr:103", size);
2522       break;
2523     case E_AVR_MACH_XMEGA4:
2524       strncat (buf, ", avr:104", size);
2525       break;
2526     case E_AVR_MACH_XMEGA5:
2527       strncat (buf, ", avr:105", size);
2528       break;
2529     case E_AVR_MACH_XMEGA6:
2530       strncat (buf, ", avr:106", size);
2531       break;
2532     case E_AVR_MACH_XMEGA7:
2533       strncat (buf, ", avr:107", size);
2534       break;
2535     default:
2536       strncat (buf, ", avr:<unknown>", size);
2537       break;
2538     }
2539
2540   size -= strlen (buf);
2541   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2542     strncat (buf, ", link-relax", size);
2543 }
2544
2545 static void
2546 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2547 {
2548   unsigned abi;
2549   unsigned arch;
2550   unsigned config;
2551   unsigned version;
2552   int has_fpu = 0;
2553   int r = 0;
2554
2555   static const char *ABI_STRINGS[] =
2556   {
2557     "ABI v0", /* use r5 as return register; only used in N1213HC */
2558     "ABI v1", /* use r0 as return register */
2559     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2560     "ABI v2fp", /* for FPU */
2561     "AABI",
2562     "ABI2 FP+"
2563   };
2564   static const char *VER_STRINGS[] =
2565   {
2566     "Andes ELF V1.3 or older",
2567     "Andes ELF V1.3.1",
2568     "Andes ELF V1.4"
2569   };
2570   static const char *ARCH_STRINGS[] =
2571   {
2572     "",
2573     "Andes Star v1.0",
2574     "Andes Star v2.0",
2575     "Andes Star v3.0",
2576     "Andes Star v3.0m"
2577   };
2578
2579   abi = EF_NDS_ABI & e_flags;
2580   arch = EF_NDS_ARCH & e_flags;
2581   config = EF_NDS_INST & e_flags;
2582   version = EF_NDS32_ELF_VERSION & e_flags;
2583
2584   memset (buf, 0, size);
2585
2586   switch (abi)
2587     {
2588     case E_NDS_ABI_V0:
2589     case E_NDS_ABI_V1:
2590     case E_NDS_ABI_V2:
2591     case E_NDS_ABI_V2FP:
2592     case E_NDS_ABI_AABI:
2593     case E_NDS_ABI_V2FP_PLUS:
2594       /* In case there are holes in the array.  */
2595       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2596       break;
2597
2598     default:
2599       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2600       break;
2601     }
2602
2603   switch (version)
2604     {
2605     case E_NDS32_ELF_VER_1_2:
2606     case E_NDS32_ELF_VER_1_3:
2607     case E_NDS32_ELF_VER_1_4:
2608       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2609       break;
2610
2611     default:
2612       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2613       break;
2614     }
2615
2616   if (E_NDS_ABI_V0 == abi)
2617     {
2618       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2619       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2620       if (arch == E_NDS_ARCH_STAR_V1_0)
2621         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2622       return;
2623     }
2624
2625   switch (arch)
2626     {
2627     case E_NDS_ARCH_STAR_V1_0:
2628     case E_NDS_ARCH_STAR_V2_0:
2629     case E_NDS_ARCH_STAR_V3_0:
2630     case E_NDS_ARCH_STAR_V3_M:
2631       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2632       break;
2633
2634     default:
2635       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2636       /* ARCH version determines how the e_flags are interpreted.
2637          If it is unknown, we cannot proceed.  */
2638       return;
2639     }
2640
2641   /* Newer ABI; Now handle architecture specific flags.  */
2642   if (arch == E_NDS_ARCH_STAR_V1_0)
2643     {
2644       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2645         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2646
2647       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2648         r += snprintf (buf + r, size -r, ", MAC");
2649
2650       if (config & E_NDS32_HAS_DIV_INST)
2651         r += snprintf (buf + r, size -r, ", DIV");
2652
2653       if (config & E_NDS32_HAS_16BIT_INST)
2654         r += snprintf (buf + r, size -r, ", 16b");
2655     }
2656   else
2657     {
2658       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2659         {
2660           if (version <= E_NDS32_ELF_VER_1_3)
2661             r += snprintf (buf + r, size -r, ", [B8]");
2662           else
2663             r += snprintf (buf + r, size -r, ", EX9");
2664         }
2665
2666       if (config & E_NDS32_HAS_MAC_DX_INST)
2667         r += snprintf (buf + r, size -r, ", MAC_DX");
2668
2669       if (config & E_NDS32_HAS_DIV_DX_INST)
2670         r += snprintf (buf + r, size -r, ", DIV_DX");
2671
2672       if (config & E_NDS32_HAS_16BIT_INST)
2673         {
2674           if (version <= E_NDS32_ELF_VER_1_3)
2675             r += snprintf (buf + r, size -r, ", 16b");
2676           else
2677             r += snprintf (buf + r, size -r, ", IFC");
2678         }
2679     }
2680
2681   if (config & E_NDS32_HAS_EXT_INST)
2682     r += snprintf (buf + r, size -r, ", PERF1");
2683
2684   if (config & E_NDS32_HAS_EXT2_INST)
2685     r += snprintf (buf + r, size -r, ", PERF2");
2686
2687   if (config & E_NDS32_HAS_FPU_INST)
2688     {
2689       has_fpu = 1;
2690       r += snprintf (buf + r, size -r, ", FPU_SP");
2691     }
2692
2693   if (config & E_NDS32_HAS_FPU_DP_INST)
2694     {
2695       has_fpu = 1;
2696       r += snprintf (buf + r, size -r, ", FPU_DP");
2697     }
2698
2699   if (config & E_NDS32_HAS_FPU_MAC_INST)
2700     {
2701       has_fpu = 1;
2702       r += snprintf (buf + r, size -r, ", FPU_MAC");
2703     }
2704
2705   if (has_fpu)
2706     {
2707       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2708         {
2709         case E_NDS32_FPU_REG_8SP_4DP:
2710           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2711           break;
2712         case E_NDS32_FPU_REG_16SP_8DP:
2713           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2714           break;
2715         case E_NDS32_FPU_REG_32SP_16DP:
2716           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2717           break;
2718         case E_NDS32_FPU_REG_32SP_32DP:
2719           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2720           break;
2721         }
2722     }
2723
2724   if (config & E_NDS32_HAS_AUDIO_INST)
2725     r += snprintf (buf + r, size -r, ", AUDIO");
2726
2727   if (config & E_NDS32_HAS_STRING_INST)
2728     r += snprintf (buf + r, size -r, ", STR");
2729
2730   if (config & E_NDS32_HAS_REDUCED_REGS)
2731     r += snprintf (buf + r, size -r, ", 16REG");
2732
2733   if (config & E_NDS32_HAS_VIDEO_INST)
2734     {
2735       if (version <= E_NDS32_ELF_VER_1_3)
2736         r += snprintf (buf + r, size -r, ", VIDEO");
2737       else
2738         r += snprintf (buf + r, size -r, ", SATURATION");
2739     }
2740
2741   if (config & E_NDS32_HAS_ENCRIPT_INST)
2742     r += snprintf (buf + r, size -r, ", ENCRP");
2743
2744   if (config & E_NDS32_HAS_L2C_INST)
2745     r += snprintf (buf + r, size -r, ", L2C");
2746 }
2747
2748 static char *
2749 get_machine_flags (unsigned e_flags, unsigned e_machine)
2750 {
2751   static char buf[1024];
2752
2753   buf[0] = '\0';
2754
2755   if (e_flags)
2756     {
2757       switch (e_machine)
2758         {
2759         default:
2760           break;
2761
2762         case EM_ARM:
2763           decode_ARM_machine_flags (e_flags, buf);
2764           break;
2765
2766         case EM_AVR:
2767           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2768           break;
2769
2770         case EM_BLACKFIN:
2771           if (e_flags & EF_BFIN_PIC)
2772             strcat (buf, ", PIC");
2773
2774           if (e_flags & EF_BFIN_FDPIC)
2775             strcat (buf, ", FDPIC");
2776
2777           if (e_flags & EF_BFIN_CODE_IN_L1)
2778             strcat (buf, ", code in L1");
2779
2780           if (e_flags & EF_BFIN_DATA_IN_L1)
2781             strcat (buf, ", data in L1");
2782
2783           break;
2784
2785         case EM_CYGNUS_FRV:
2786           switch (e_flags & EF_FRV_CPU_MASK)
2787             {
2788             case EF_FRV_CPU_GENERIC:
2789               break;
2790
2791             default:
2792               strcat (buf, ", fr???");
2793               break;
2794
2795             case EF_FRV_CPU_FR300:
2796               strcat (buf, ", fr300");
2797               break;
2798
2799             case EF_FRV_CPU_FR400:
2800               strcat (buf, ", fr400");
2801               break;
2802             case EF_FRV_CPU_FR405:
2803               strcat (buf, ", fr405");
2804               break;
2805
2806             case EF_FRV_CPU_FR450:
2807               strcat (buf, ", fr450");
2808               break;
2809
2810             case EF_FRV_CPU_FR500:
2811               strcat (buf, ", fr500");
2812               break;
2813             case EF_FRV_CPU_FR550:
2814               strcat (buf, ", fr550");
2815               break;
2816
2817             case EF_FRV_CPU_SIMPLE:
2818               strcat (buf, ", simple");
2819               break;
2820             case EF_FRV_CPU_TOMCAT:
2821               strcat (buf, ", tomcat");
2822               break;
2823             }
2824           break;
2825
2826         case EM_68K:
2827           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2828             strcat (buf, ", m68000");
2829           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2830             strcat (buf, ", cpu32");
2831           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2832             strcat (buf, ", fido_a");
2833           else
2834             {
2835               char const * isa = _("unknown");
2836               char const * mac = _("unknown mac");
2837               char const * additional = NULL;
2838
2839               switch (e_flags & EF_M68K_CF_ISA_MASK)
2840                 {
2841                 case EF_M68K_CF_ISA_A_NODIV:
2842                   isa = "A";
2843                   additional = ", nodiv";
2844                   break;
2845                 case EF_M68K_CF_ISA_A:
2846                   isa = "A";
2847                   break;
2848                 case EF_M68K_CF_ISA_A_PLUS:
2849                   isa = "A+";
2850                   break;
2851                 case EF_M68K_CF_ISA_B_NOUSP:
2852                   isa = "B";
2853                   additional = ", nousp";
2854                   break;
2855                 case EF_M68K_CF_ISA_B:
2856                   isa = "B";
2857                   break;
2858                 case EF_M68K_CF_ISA_C:
2859                   isa = "C";
2860                   break;
2861                 case EF_M68K_CF_ISA_C_NODIV:
2862                   isa = "C";
2863                   additional = ", nodiv";
2864                   break;
2865                 }
2866               strcat (buf, ", cf, isa ");
2867               strcat (buf, isa);
2868               if (additional)
2869                 strcat (buf, additional);
2870               if (e_flags & EF_M68K_CF_FLOAT)
2871                 strcat (buf, ", float");
2872               switch (e_flags & EF_M68K_CF_MAC_MASK)
2873                 {
2874                 case 0:
2875                   mac = NULL;
2876                   break;
2877                 case EF_M68K_CF_MAC:
2878                   mac = "mac";
2879                   break;
2880                 case EF_M68K_CF_EMAC:
2881                   mac = "emac";
2882                   break;
2883                 case EF_M68K_CF_EMAC_B:
2884                   mac = "emac_b";
2885                   break;
2886                 }
2887               if (mac)
2888                 {
2889                   strcat (buf, ", ");
2890                   strcat (buf, mac);
2891                 }
2892             }
2893           break;
2894
2895         case EM_CYGNUS_MEP:
2896           switch (e_flags & EF_MEP_CPU_MASK)
2897             {
2898             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2899             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2900             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2901             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2902             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2903             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2904             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2905             }
2906
2907           switch (e_flags & EF_MEP_COP_MASK)
2908             {
2909             case EF_MEP_COP_NONE: break;
2910             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2911             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2912             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2913             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2914             default: strcat (buf, _("<unknown MeP copro type>")); break;
2915             }
2916
2917           if (e_flags & EF_MEP_LIBRARY)
2918             strcat (buf, ", Built for Library");
2919
2920           if (e_flags & EF_MEP_INDEX_MASK)
2921             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2922                      e_flags & EF_MEP_INDEX_MASK);
2923
2924           if (e_flags & ~ EF_MEP_ALL_FLAGS)
2925             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2926                      e_flags & ~ EF_MEP_ALL_FLAGS);
2927           break;
2928
2929         case EM_PPC:
2930           if (e_flags & EF_PPC_EMB)
2931             strcat (buf, ", emb");
2932
2933           if (e_flags & EF_PPC_RELOCATABLE)
2934             strcat (buf, _(", relocatable"));
2935
2936           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2937             strcat (buf, _(", relocatable-lib"));
2938           break;
2939
2940         case EM_PPC64:
2941           if (e_flags & EF_PPC64_ABI)
2942             {
2943               char abi[] = ", abiv0";
2944
2945               abi[6] += e_flags & EF_PPC64_ABI;
2946               strcat (buf, abi);
2947             }
2948           break;
2949
2950         case EM_V800:
2951           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2952             strcat (buf, ", RH850 ABI");
2953
2954           if (e_flags & EF_V800_850E3)
2955             strcat (buf, ", V3 architecture");
2956
2957           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2958             strcat (buf, ", FPU not used");
2959
2960           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2961             strcat (buf, ", regmode: COMMON");
2962
2963           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2964             strcat (buf, ", r4 not used");
2965
2966           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2967             strcat (buf, ", r30 not used");
2968
2969           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2970             strcat (buf, ", r5 not used");
2971
2972           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2973             strcat (buf, ", r2 not used");
2974
2975           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2976             {
2977               switch (e_flags & - e_flags)
2978                 {
2979                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2980                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2981                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2982                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2983                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2984                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2985                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2986                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2987                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2988                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2989                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2990                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2991                 default: break;
2992                 }
2993             }
2994           break;
2995
2996         case EM_V850:
2997         case EM_CYGNUS_V850:
2998           switch (e_flags & EF_V850_ARCH)
2999             {
3000             case E_V850E3V5_ARCH:
3001               strcat (buf, ", v850e3v5");
3002               break;
3003             case E_V850E2V3_ARCH:
3004               strcat (buf, ", v850e2v3");
3005               break;
3006             case E_V850E2_ARCH:
3007               strcat (buf, ", v850e2");
3008               break;
3009             case E_V850E1_ARCH:
3010               strcat (buf, ", v850e1");
3011               break;
3012             case E_V850E_ARCH:
3013               strcat (buf, ", v850e");
3014               break;
3015             case E_V850_ARCH:
3016               strcat (buf, ", v850");
3017               break;
3018             default:
3019               strcat (buf, _(", unknown v850 architecture variant"));
3020               break;
3021             }
3022           break;
3023
3024         case EM_M32R:
3025         case EM_CYGNUS_M32R:
3026           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3027             strcat (buf, ", m32r");
3028           break;
3029
3030         case EM_MIPS:
3031         case EM_MIPS_RS3_LE:
3032           if (e_flags & EF_MIPS_NOREORDER)
3033             strcat (buf, ", noreorder");
3034
3035           if (e_flags & EF_MIPS_PIC)
3036             strcat (buf, ", pic");
3037
3038           if (e_flags & EF_MIPS_CPIC)
3039             strcat (buf, ", cpic");
3040
3041           if (e_flags & EF_MIPS_UCODE)
3042             strcat (buf, ", ugen_reserved");
3043
3044           if (e_flags & EF_MIPS_ABI2)
3045             strcat (buf, ", abi2");
3046
3047           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3048             strcat (buf, ", odk first");
3049
3050           if (e_flags & EF_MIPS_32BITMODE)
3051             strcat (buf, ", 32bitmode");
3052
3053           if (e_flags & EF_MIPS_NAN2008)
3054             strcat (buf, ", nan2008");
3055
3056           if (e_flags & EF_MIPS_FP64)
3057             strcat (buf, ", fp64");
3058
3059           switch ((e_flags & EF_MIPS_MACH))
3060             {
3061             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3062             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3063             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3064             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3065             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3066             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3067             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3068             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3069             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3070             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3071             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3072             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3073             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3074             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3075             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3076             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3077             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3078             case 0:
3079             /* We simply ignore the field in this case to avoid confusion:
3080                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3081                extension.  */
3082               break;
3083             default: strcat (buf, _(", unknown CPU")); break;
3084             }
3085
3086           switch ((e_flags & EF_MIPS_ABI))
3087             {
3088             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3089             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3090             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3091             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3092             case 0:
3093             /* We simply ignore the field in this case to avoid confusion:
3094                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3095                This means it is likely to be an o32 file, but not for
3096                sure.  */
3097               break;
3098             default: strcat (buf, _(", unknown ABI")); break;
3099             }
3100
3101           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3102             strcat (buf, ", mdmx");
3103
3104           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3105             strcat (buf, ", mips16");
3106
3107           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3108             strcat (buf, ", micromips");
3109
3110           switch ((e_flags & EF_MIPS_ARCH))
3111             {
3112             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3113             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3114             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3115             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3116             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3117             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3118             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3119             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3120             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3121             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3122             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3123             default: strcat (buf, _(", unknown ISA")); break;
3124             }
3125           break;
3126
3127         case EM_NDS32:
3128           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3129           break;
3130
3131         case EM_SH:
3132           switch ((e_flags & EF_SH_MACH_MASK))
3133             {
3134             case EF_SH1: strcat (buf, ", sh1"); break;
3135             case EF_SH2: strcat (buf, ", sh2"); break;
3136             case EF_SH3: strcat (buf, ", sh3"); break;
3137             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3138             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3139             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3140             case EF_SH3E: strcat (buf, ", sh3e"); break;
3141             case EF_SH4: strcat (buf, ", sh4"); break;
3142             case EF_SH5: strcat (buf, ", sh5"); break;
3143             case EF_SH2E: strcat (buf, ", sh2e"); break;
3144             case EF_SH4A: strcat (buf, ", sh4a"); break;
3145             case EF_SH2A: strcat (buf, ", sh2a"); break;
3146             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3147             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3148             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3149             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3150             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3151             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3152             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3153             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3154             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3155             default: strcat (buf, _(", unknown ISA")); break;
3156             }
3157
3158           if (e_flags & EF_SH_PIC)
3159             strcat (buf, ", pic");
3160
3161           if (e_flags & EF_SH_FDPIC)
3162             strcat (buf, ", fdpic");
3163           break;
3164
3165         case EM_OR1K:
3166           if (e_flags & EF_OR1K_NODELAY)
3167             strcat (buf, ", no delay");
3168           break;
3169
3170         case EM_SPARCV9:
3171           if (e_flags & EF_SPARC_32PLUS)
3172             strcat (buf, ", v8+");
3173
3174           if (e_flags & EF_SPARC_SUN_US1)
3175             strcat (buf, ", ultrasparcI");
3176
3177           if (e_flags & EF_SPARC_SUN_US3)
3178             strcat (buf, ", ultrasparcIII");
3179
3180           if (e_flags & EF_SPARC_HAL_R1)
3181             strcat (buf, ", halr1");
3182
3183           if (e_flags & EF_SPARC_LEDATA)
3184             strcat (buf, ", ledata");
3185
3186           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3187             strcat (buf, ", tso");
3188
3189           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3190             strcat (buf, ", pso");
3191
3192           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3193             strcat (buf, ", rmo");
3194           break;
3195
3196         case EM_PARISC:
3197           switch (e_flags & EF_PARISC_ARCH)
3198             {
3199             case EFA_PARISC_1_0:
3200               strcpy (buf, ", PA-RISC 1.0");
3201               break;
3202             case EFA_PARISC_1_1:
3203               strcpy (buf, ", PA-RISC 1.1");
3204               break;
3205             case EFA_PARISC_2_0:
3206               strcpy (buf, ", PA-RISC 2.0");
3207               break;
3208             default:
3209               break;
3210             }
3211           if (e_flags & EF_PARISC_TRAPNIL)
3212             strcat (buf, ", trapnil");
3213           if (e_flags & EF_PARISC_EXT)
3214             strcat (buf, ", ext");
3215           if (e_flags & EF_PARISC_LSB)
3216             strcat (buf, ", lsb");
3217           if (e_flags & EF_PARISC_WIDE)
3218             strcat (buf, ", wide");
3219           if (e_flags & EF_PARISC_NO_KABP)
3220             strcat (buf, ", no kabp");
3221           if (e_flags & EF_PARISC_LAZYSWAP)
3222             strcat (buf, ", lazyswap");
3223           break;
3224
3225         case EM_PJ:
3226         case EM_PJ_OLD:
3227           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3228             strcat (buf, ", new calling convention");
3229
3230           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3231             strcat (buf, ", gnu calling convention");
3232           break;
3233
3234         case EM_IA_64:
3235           if ((e_flags & EF_IA_64_ABI64))
3236             strcat (buf, ", 64-bit");
3237           else
3238             strcat (buf, ", 32-bit");
3239           if ((e_flags & EF_IA_64_REDUCEDFP))
3240             strcat (buf, ", reduced fp model");
3241           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3242             strcat (buf, ", no function descriptors, constant gp");
3243           else if ((e_flags & EF_IA_64_CONS_GP))
3244             strcat (buf, ", constant gp");
3245           if ((e_flags & EF_IA_64_ABSOLUTE))
3246             strcat (buf, ", absolute");
3247           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3248             {
3249               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3250                 strcat (buf, ", vms_linkages");
3251               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3252                 {
3253                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3254                   break;
3255                 case EF_IA_64_VMS_COMCOD_WARNING:
3256                   strcat (buf, ", warning");
3257                   break;
3258                 case EF_IA_64_VMS_COMCOD_ERROR:
3259                   strcat (buf, ", error");
3260                   break;
3261                 case EF_IA_64_VMS_COMCOD_ABORT:
3262                   strcat (buf, ", abort");
3263                   break;
3264                 default:
3265                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3266                         e_flags & EF_IA_64_VMS_COMCOD);
3267                   strcat (buf, ", <unknown>");
3268                 }
3269             }
3270           break;
3271
3272         case EM_VAX:
3273           if ((e_flags & EF_VAX_NONPIC))
3274             strcat (buf, ", non-PIC");
3275           if ((e_flags & EF_VAX_DFLOAT))
3276             strcat (buf, ", D-Float");
3277           if ((e_flags & EF_VAX_GFLOAT))
3278             strcat (buf, ", G-Float");
3279           break;
3280
3281         case EM_VISIUM:
3282           if (e_flags & EF_VISIUM_ARCH_MCM)
3283             strcat (buf, ", mcm");
3284           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3285             strcat (buf, ", mcm24");
3286           if (e_flags & EF_VISIUM_ARCH_GR6)
3287             strcat (buf, ", gr6");
3288           break;
3289
3290         case EM_RL78:
3291           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3292             {
3293             case E_FLAG_RL78_ANY_CPU: break;
3294             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3295             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3296             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3297             }
3298           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3299             strcat (buf, ", 64-bit doubles");
3300           break;
3301
3302         case EM_RX:
3303           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3304             strcat (buf, ", 64-bit doubles");
3305           if (e_flags & E_FLAG_RX_DSP)
3306             strcat (buf, ", dsp");
3307           if (e_flags & E_FLAG_RX_PID)
3308             strcat (buf, ", pid");
3309           if (e_flags & E_FLAG_RX_ABI)
3310             strcat (buf, ", RX ABI");
3311           if (e_flags & E_FLAG_RX_SINSNS_SET)
3312             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3313                     ? ", uses String instructions" : ", bans String instructions");
3314           break;
3315
3316         case EM_S390:
3317           if (e_flags & EF_S390_HIGH_GPRS)
3318             strcat (buf, ", highgprs");
3319           break;
3320
3321         case EM_TI_C6000:
3322           if ((e_flags & EF_C6000_REL))
3323             strcat (buf, ", relocatable module");
3324           break;
3325
3326         case EM_MSP430:
3327           strcat (buf, _(": architecture variant: "));
3328           switch (e_flags & EF_MSP430_MACH)
3329             {
3330             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3331             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3332             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3333             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3334             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3335             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3336             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3337             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3338             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3339             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3340             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3341             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3342             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3343             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3344             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3345             default:
3346               strcat (buf, _(": unknown")); break;
3347             }
3348
3349           if (e_flags & ~ EF_MSP430_MACH)
3350             strcat (buf, _(": unknown extra flag bits also present"));
3351         }
3352     }
3353
3354   return buf;
3355 }
3356
3357 static const char *
3358 get_osabi_name (unsigned int osabi)
3359 {
3360   static char buff[32];
3361
3362   switch (osabi)
3363     {
3364     case ELFOSABI_NONE:         return "UNIX - System V";
3365     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3366     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3367     case ELFOSABI_GNU:          return "UNIX - GNU";
3368     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3369     case ELFOSABI_AIX:          return "UNIX - AIX";
3370     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3371     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3372     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3373     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3374     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3375     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3376     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3377     case ELFOSABI_AROS:         return "AROS";
3378     case ELFOSABI_FENIXOS:      return "FenixOS";
3379     default:
3380       if (osabi >= 64)
3381         switch (elf_header.e_machine)
3382           {
3383           case EM_ARM:
3384             switch (osabi)
3385               {
3386               case ELFOSABI_ARM:        return "ARM";
3387               default:
3388                 break;
3389               }
3390             break;
3391
3392           case EM_MSP430:
3393           case EM_MSP430_OLD:
3394           case EM_VISIUM:
3395             switch (osabi)
3396               {
3397               case ELFOSABI_STANDALONE: return _("Standalone App");
3398               default:
3399                 break;
3400               }
3401             break;
3402
3403           case EM_TI_C6000:
3404             switch (osabi)
3405               {
3406               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3407               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3408               default:
3409                 break;
3410               }
3411             break;
3412
3413           default:
3414             break;
3415           }
3416       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3417       return buff;
3418     }
3419 }
3420
3421 static const char *
3422 get_aarch64_segment_type (unsigned long type)
3423 {
3424   switch (type)
3425     {
3426     case PT_AARCH64_ARCHEXT:
3427       return "AARCH64_ARCHEXT";
3428     default:
3429       break;
3430     }
3431
3432   return NULL;
3433 }
3434
3435 static const char *
3436 get_arm_segment_type (unsigned long type)
3437 {
3438   switch (type)
3439     {
3440     case PT_ARM_EXIDX:
3441       return "EXIDX";
3442     default:
3443       break;
3444     }
3445
3446   return NULL;
3447 }
3448
3449 static const char *
3450 get_mips_segment_type (unsigned long type)
3451 {
3452   switch (type)
3453     {
3454     case PT_MIPS_REGINFO:
3455       return "REGINFO";
3456     case PT_MIPS_RTPROC:
3457       return "RTPROC";
3458     case PT_MIPS_OPTIONS:
3459       return "OPTIONS";
3460     case PT_MIPS_ABIFLAGS:
3461       return "ABIFLAGS";
3462     default:
3463       break;
3464     }
3465
3466   return NULL;
3467 }
3468
3469 static const char *
3470 get_parisc_segment_type (unsigned long type)
3471 {
3472   switch (type)
3473     {
3474     case PT_HP_TLS:             return "HP_TLS";
3475     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3476     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3477     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3478     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3479     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3480     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3481     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3482     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3483     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3484     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3485     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3486     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3487     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3488     case PT_HP_STACK:           return "HP_STACK";
3489     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3490     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3491     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3492     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3493     default:
3494       break;
3495     }
3496
3497   return NULL;
3498 }
3499
3500 static const char *
3501 get_ia64_segment_type (unsigned long type)
3502 {
3503   switch (type)
3504     {
3505     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3506     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3507     case PT_HP_TLS:             return "HP_TLS";
3508     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3509     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3510     case PT_IA_64_HP_STACK:     return "HP_STACK";
3511     default:
3512       break;
3513     }
3514
3515   return NULL;
3516 }
3517
3518 static const char *
3519 get_tic6x_segment_type (unsigned long type)
3520 {
3521   switch (type)
3522     {
3523     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3524     default:
3525       break;
3526     }
3527
3528   return NULL;
3529 }
3530
3531 static const char *
3532 get_segment_type (unsigned long p_type)
3533 {
3534   static char buff[32];
3535
3536   switch (p_type)
3537     {
3538     case PT_NULL:       return "NULL";
3539     case PT_LOAD:       return "LOAD";
3540     case PT_DYNAMIC:    return "DYNAMIC";
3541     case PT_INTERP:     return "INTERP";
3542     case PT_NOTE:       return "NOTE";
3543     case PT_SHLIB:      return "SHLIB";
3544     case PT_PHDR:       return "PHDR";
3545     case PT_TLS:        return "TLS";
3546
3547     case PT_GNU_EH_FRAME:
3548                         return "GNU_EH_FRAME";
3549     case PT_GNU_STACK:  return "GNU_STACK";
3550     case PT_GNU_RELRO:  return "GNU_RELRO";
3551
3552     default:
3553       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3554         {
3555           const char * result;
3556
3557           switch (elf_header.e_machine)
3558             {
3559             case EM_AARCH64:
3560               result = get_aarch64_segment_type (p_type);
3561               break;
3562             case EM_ARM:
3563               result = get_arm_segment_type (p_type);
3564               break;
3565             case EM_MIPS:
3566             case EM_MIPS_RS3_LE:
3567               result = get_mips_segment_type (p_type);
3568               break;
3569             case EM_PARISC:
3570               result = get_parisc_segment_type (p_type);
3571               break;
3572             case EM_IA_64:
3573               result = get_ia64_segment_type (p_type);
3574               break;
3575             case EM_TI_C6000:
3576               result = get_tic6x_segment_type (p_type);
3577               break;
3578             default:
3579               result = NULL;
3580               break;
3581             }
3582
3583           if (result != NULL)
3584             return result;
3585
3586           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3587         }
3588       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3589         {
3590           const char * result;
3591
3592           switch (elf_header.e_machine)
3593             {
3594             case EM_PARISC:
3595               result = get_parisc_segment_type (p_type);
3596               break;
3597             case EM_IA_64:
3598               result = get_ia64_segment_type (p_type);
3599               break;
3600             default:
3601               result = NULL;
3602               break;
3603             }
3604
3605           if (result != NULL)
3606             return result;
3607
3608           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3609         }
3610       else
3611         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3612
3613       return buff;
3614     }
3615 }
3616
3617 static const char *
3618 get_mips_section_type_name (unsigned int sh_type)
3619 {
3620   switch (sh_type)
3621     {
3622     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3623     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3624     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3625     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3626     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3627     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3628     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3629     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3630     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3631     case SHT_MIPS_RELD:          return "MIPS_RELD";
3632     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3633     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3634     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3635     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3636     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3637     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3638     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3639     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3640     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3641     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3642     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3643     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3644     case SHT_MIPS_LINE:          return "MIPS_LINE";
3645     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3646     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3647     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3648     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3649     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3650     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3651     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3652     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3653     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3654     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3655     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3656     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3657     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3658     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3659     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3660     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3661     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3662     default:
3663       break;
3664     }
3665   return NULL;
3666 }
3667
3668 static const char *
3669 get_parisc_section_type_name (unsigned int sh_type)
3670 {
3671   switch (sh_type)
3672     {
3673     case SHT_PARISC_EXT:        return "PARISC_EXT";
3674     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3675     case SHT_PARISC_DOC:        return "PARISC_DOC";
3676     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3677     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3678     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3679     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3680     default:
3681       break;
3682     }
3683   return NULL;
3684 }
3685
3686 static const char *
3687 get_ia64_section_type_name (unsigned int sh_type)
3688 {
3689   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3690   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3691     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3692
3693   switch (sh_type)
3694     {
3695     case SHT_IA_64_EXT:                return "IA_64_EXT";
3696     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3697     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3698     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3699     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3700     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3701     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3702     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3703     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3704     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3705     default:
3706       break;
3707     }
3708   return NULL;
3709 }
3710
3711 static const char *
3712 get_x86_64_section_type_name (unsigned int sh_type)
3713 {
3714   switch (sh_type)
3715     {
3716     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3717     default:
3718       break;
3719     }
3720   return NULL;
3721 }
3722
3723 static const char *
3724 get_aarch64_section_type_name (unsigned int sh_type)
3725 {
3726   switch (sh_type)
3727     {
3728     case SHT_AARCH64_ATTRIBUTES:
3729       return "AARCH64_ATTRIBUTES";
3730     default:
3731       break;
3732     }
3733   return NULL;
3734 }
3735
3736 static const char *
3737 get_arm_section_type_name (unsigned int sh_type)
3738 {
3739   switch (sh_type)
3740     {
3741     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3742     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3743     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3744     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3745     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3746     default:
3747       break;
3748     }
3749   return NULL;
3750 }
3751
3752 static const char *
3753 get_tic6x_section_type_name (unsigned int sh_type)
3754 {
3755   switch (sh_type)
3756     {
3757     case SHT_C6000_UNWIND:
3758       return "C6000_UNWIND";
3759     case SHT_C6000_PREEMPTMAP:
3760       return "C6000_PREEMPTMAP";
3761     case SHT_C6000_ATTRIBUTES:
3762       return "C6000_ATTRIBUTES";
3763     case SHT_TI_ICODE:
3764       return "TI_ICODE";
3765     case SHT_TI_XREF:
3766       return "TI_XREF";
3767     case SHT_TI_HANDLER:
3768       return "TI_HANDLER";
3769     case SHT_TI_INITINFO:
3770       return "TI_INITINFO";
3771     case SHT_TI_PHATTRS:
3772       return "TI_PHATTRS";
3773     default:
3774       break;
3775     }
3776   return NULL;
3777 }
3778
3779 static const char *
3780 get_msp430x_section_type_name (unsigned int sh_type)
3781 {
3782   switch (sh_type)
3783     {
3784     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3785     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3786     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3787     default: return NULL;
3788     }
3789 }
3790
3791 static const char *
3792 get_v850_section_type_name (unsigned int sh_type)
3793 {
3794   switch (sh_type)
3795     {
3796     case SHT_V850_SCOMMON: return "V850 Small Common";
3797     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3798     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3799     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3800     case SHT_RENESAS_INFO: return "RENESAS INFO";
3801     default: return NULL;
3802     }
3803 }
3804
3805 static const char *
3806 get_section_type_name (unsigned int sh_type)
3807 {
3808   static char buff[32];
3809
3810   switch (sh_type)
3811     {
3812     case SHT_NULL:              return "NULL";
3813     case SHT_PROGBITS:          return "PROGBITS";
3814     case SHT_SYMTAB:            return "SYMTAB";
3815     case SHT_STRTAB:            return "STRTAB";
3816     case SHT_RELA:              return "RELA";
3817     case SHT_HASH:              return "HASH";
3818     case SHT_DYNAMIC:           return "DYNAMIC";
3819     case SHT_NOTE:              return "NOTE";
3820     case SHT_NOBITS:            return "NOBITS";
3821     case SHT_REL:               return "REL";
3822     case SHT_SHLIB:             return "SHLIB";
3823     case SHT_DYNSYM:            return "DYNSYM";
3824     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3825     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3826     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3827     case SHT_GNU_HASH:          return "GNU_HASH";
3828     case SHT_GROUP:             return "GROUP";
3829     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3830     case SHT_GNU_verdef:        return "VERDEF";
3831     case SHT_GNU_verneed:       return "VERNEED";
3832     case SHT_GNU_versym:        return "VERSYM";
3833     case 0x6ffffff0:            return "VERSYM";
3834     case 0x6ffffffc:            return "VERDEF";
3835     case 0x7ffffffd:            return "AUXILIARY";
3836     case 0x7fffffff:            return "FILTER";
3837     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3838
3839     default:
3840       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3841         {
3842           const char * result;
3843
3844           switch (elf_header.e_machine)
3845             {
3846             case EM_MIPS:
3847             case EM_MIPS_RS3_LE:
3848               result = get_mips_section_type_name (sh_type);
3849               break;
3850             case EM_PARISC:
3851               result = get_parisc_section_type_name (sh_type);
3852               break;
3853             case EM_IA_64:
3854               result = get_ia64_section_type_name (sh_type);
3855               break;
3856             case EM_X86_64:
3857             case EM_L1OM:
3858             case EM_K1OM:
3859               result = get_x86_64_section_type_name (sh_type);
3860               break;
3861             case EM_AARCH64:
3862               result = get_aarch64_section_type_name (sh_type);
3863               break;
3864             case EM_ARM:
3865               result = get_arm_section_type_name (sh_type);
3866               break;
3867             case EM_TI_C6000:
3868               result = get_tic6x_section_type_name (sh_type);
3869               break;
3870             case EM_MSP430:
3871               result = get_msp430x_section_type_name (sh_type);
3872               break;
3873             case EM_V800:
3874             case EM_V850:
3875             case EM_CYGNUS_V850:
3876               result = get_v850_section_type_name (sh_type);
3877               break;
3878             default:
3879               result = NULL;
3880               break;
3881             }
3882
3883           if (result != NULL)
3884             return result;
3885
3886           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3887         }
3888       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3889         {
3890           const char * result;
3891
3892           switch (elf_header.e_machine)
3893             {
3894             case EM_IA_64:
3895               result = get_ia64_section_type_name (sh_type);
3896               break;
3897             default:
3898               result = NULL;
3899               break;
3900             }
3901
3902           if (result != NULL)
3903             return result;
3904
3905           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3906         }
3907       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3908         {
3909           switch (elf_header.e_machine)
3910             {
3911             case EM_V800:
3912             case EM_V850:
3913             case EM_CYGNUS_V850:
3914               return get_v850_section_type_name (sh_type);
3915             default:
3916               break;
3917             }
3918
3919           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3920         }
3921       else
3922         /* This message is probably going to be displayed in a 15
3923            character wide field, so put the hex value first.  */
3924         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3925
3926       return buff;
3927     }
3928 }
3929
3930 #define OPTION_DEBUG_DUMP       512
3931 #define OPTION_DYN_SYMS         513
3932 #define OPTION_DWARF_DEPTH      514
3933 #define OPTION_DWARF_START      515
3934 #define OPTION_DWARF_CHECK      516
3935
3936 static struct option options[] =
3937 {
3938   {"all",              no_argument, 0, 'a'},
3939   {"file-header",      no_argument, 0, 'h'},
3940   {"program-headers",  no_argument, 0, 'l'},
3941   {"headers",          no_argument, 0, 'e'},
3942   {"histogram",        no_argument, 0, 'I'},
3943   {"segments",         no_argument, 0, 'l'},
3944   {"sections",         no_argument, 0, 'S'},
3945   {"section-headers",  no_argument, 0, 'S'},
3946   {"section-groups",   no_argument, 0, 'g'},
3947   {"section-details",  no_argument, 0, 't'},
3948   {"full-section-name",no_argument, 0, 'N'},
3949   {"symbols",          no_argument, 0, 's'},
3950   {"syms",             no_argument, 0, 's'},
3951   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3952   {"relocs",           no_argument, 0, 'r'},
3953   {"notes",            no_argument, 0, 'n'},
3954   {"dynamic",          no_argument, 0, 'd'},
3955   {"arch-specific",    no_argument, 0, 'A'},
3956   {"version-info",     no_argument, 0, 'V'},
3957   {"use-dynamic",      no_argument, 0, 'D'},
3958   {"unwind",           no_argument, 0, 'u'},
3959   {"archive-index",    no_argument, 0, 'c'},
3960   {"hex-dump",         required_argument, 0, 'x'},
3961   {"relocated-dump",   required_argument, 0, 'R'},
3962   {"string-dump",      required_argument, 0, 'p'},
3963 #ifdef SUPPORT_DISASSEMBLY
3964   {"instruction-dump", required_argument, 0, 'i'},
3965 #endif
3966   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3967
3968   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3969   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3970   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3971
3972   {"version",          no_argument, 0, 'v'},
3973   {"wide",             no_argument, 0, 'W'},
3974   {"help",             no_argument, 0, 'H'},
3975   {0,                  no_argument, 0, 0}
3976 };
3977
3978 static void
3979 usage (FILE * stream)
3980 {
3981   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3982   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3983   fprintf (stream, _(" Options are:\n\
3984   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3985   -h --file-header       Display the ELF file header\n\
3986   -l --program-headers   Display the program headers\n\
3987      --segments          An alias for --program-headers\n\
3988   -S --section-headers   Display the sections' header\n\
3989      --sections          An alias for --section-headers\n\
3990   -g --section-groups    Display the section groups\n\
3991   -t --section-details   Display the section details\n\
3992   -e --headers           Equivalent to: -h -l -S\n\
3993   -s --syms              Display the symbol table\n\
3994      --symbols           An alias for --syms\n\
3995   --dyn-syms             Display the dynamic symbol table\n\
3996   -n --notes             Display the core notes (if present)\n\
3997   -r --relocs            Display the relocations (if present)\n\
3998   -u --unwind            Display the unwind info (if present)\n\
3999   -d --dynamic           Display the dynamic section (if present)\n\
4000   -V --version-info      Display the version sections (if present)\n\
4001   -A --arch-specific     Display architecture specific information (if any)\n\
4002   -c --archive-index     Display the symbol/file index in an archive\n\
4003   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4004   -x --hex-dump=<number|name>\n\
4005                          Dump the contents of section <number|name> as bytes\n\
4006   -p --string-dump=<number|name>\n\
4007                          Dump the contents of section <number|name> as strings\n\
4008   -R --relocated-dump=<number|name>\n\
4009                          Dump the contents of section <number|name> as relocated bytes\n\
4010   -w[lLiaprmfFsoRt] or\n\
4011   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4012                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4013                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4014                =addr,=cu_index]\n\
4015                          Display the contents of DWARF2 debug sections\n"));
4016   fprintf (stream, _("\
4017   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4018   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4019                          or deeper\n"));
4020 #ifdef SUPPORT_DISASSEMBLY
4021   fprintf (stream, _("\
4022   -i --instruction-dump=<number|name>\n\
4023                          Disassemble the contents of section <number|name>\n"));
4024 #endif
4025   fprintf (stream, _("\
4026   -I --histogram         Display histogram of bucket list lengths\n\
4027   -W --wide              Allow output width to exceed 80 characters\n\
4028   @<file>                Read options from <file>\n\
4029   -H --help              Display this information\n\
4030   -v --version           Display the version number of readelf\n"));
4031
4032   if (REPORT_BUGS_TO[0] && stream == stdout)
4033     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4034
4035   exit (stream == stdout ? 0 : 1);
4036 }
4037
4038 /* Record the fact that the user wants the contents of section number
4039    SECTION to be displayed using the method(s) encoded as flags bits
4040    in TYPE.  Note, TYPE can be zero if we are creating the array for
4041    the first time.  */
4042
4043 static void
4044 request_dump_bynumber (unsigned int section, dump_type type)
4045 {
4046   if (section >= num_dump_sects)
4047     {
4048       dump_type * new_dump_sects;
4049
4050       new_dump_sects = (dump_type *) calloc (section + 1,
4051                                              sizeof (* dump_sects));
4052
4053       if (new_dump_sects == NULL)
4054         error (_("Out of memory allocating dump request table.\n"));
4055       else
4056         {
4057           /* Copy current flag settings.  */
4058           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4059
4060           free (dump_sects);
4061
4062           dump_sects = new_dump_sects;
4063           num_dump_sects = section + 1;
4064         }
4065     }
4066
4067   if (dump_sects)
4068     dump_sects[section] |= type;
4069
4070   return;
4071 }
4072
4073 /* Request a dump by section name.  */
4074
4075 static void
4076 request_dump_byname (const char * section, dump_type type)
4077 {
4078   struct dump_list_entry * new_request;
4079
4080   new_request = (struct dump_list_entry *)
4081       malloc (sizeof (struct dump_list_entry));
4082   if (!new_request)
4083     error (_("Out of memory allocating dump request table.\n"));
4084
4085   new_request->name = strdup (section);
4086   if (!new_request->name)
4087     error (_("Out of memory allocating dump request table.\n"));
4088
4089   new_request->type = type;
4090
4091   new_request->next = dump_sects_byname;
4092   dump_sects_byname = new_request;
4093 }
4094
4095 static inline void
4096 request_dump (dump_type type)
4097 {
4098   int section;
4099   char * cp;
4100
4101   do_dump++;
4102   section = strtoul (optarg, & cp, 0);
4103
4104   if (! *cp && section >= 0)
4105     request_dump_bynumber (section, type);
4106   else
4107     request_dump_byname (optarg, type);
4108 }
4109
4110
4111 static void
4112 parse_args (int argc, char ** argv)
4113 {
4114   int c;
4115
4116   if (argc < 2)
4117     usage (stderr);
4118
4119   while ((c = getopt_long
4120           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4121     {
4122       switch (c)
4123         {
4124         case 0:
4125           /* Long options.  */
4126           break;
4127         case 'H':
4128           usage (stdout);
4129           break;
4130
4131         case 'a':
4132           do_syms++;
4133           do_reloc++;
4134           do_unwind++;
4135           do_dynamic++;
4136           do_header++;
4137           do_sections++;
4138           do_section_groups++;
4139           do_segments++;
4140           do_version++;
4141           do_histogram++;
4142           do_arch++;
4143           do_notes++;
4144           break;
4145         case 'g':
4146           do_section_groups++;
4147           break;
4148         case 't':
4149         case 'N':
4150           do_sections++;
4151           do_section_details++;
4152           break;
4153         case 'e':
4154           do_header++;
4155           do_sections++;
4156           do_segments++;
4157           break;
4158         case 'A':
4159           do_arch++;
4160           break;
4161         case 'D':
4162           do_using_dynamic++;
4163           break;
4164         case 'r':
4165           do_reloc++;
4166           break;
4167         case 'u':
4168           do_unwind++;
4169           break;
4170         case 'h':
4171           do_header++;
4172           break;
4173         case 'l':
4174           do_segments++;
4175           break;
4176         case 's':
4177           do_syms++;
4178           break;
4179         case 'S':
4180           do_sections++;
4181           break;
4182         case 'd':
4183           do_dynamic++;
4184           break;
4185         case 'I':
4186           do_histogram++;
4187           break;
4188         case 'n':
4189           do_notes++;
4190           break;
4191         case 'c':
4192           do_archive_index++;
4193           break;
4194         case 'x':
4195           request_dump (HEX_DUMP);
4196           break;
4197         case 'p':
4198           request_dump (STRING_DUMP);
4199           break;
4200         case 'R':
4201           request_dump (RELOC_DUMP);
4202           break;
4203         case 'w':
4204           do_dump++;
4205           if (optarg == 0)
4206             {
4207               do_debugging = 1;
4208               dwarf_select_sections_all ();
4209             }
4210           else
4211             {
4212               do_debugging = 0;
4213               dwarf_select_sections_by_letters (optarg);
4214             }
4215           break;
4216         case OPTION_DEBUG_DUMP:
4217           do_dump++;
4218           if (optarg == 0)
4219             do_debugging = 1;
4220           else
4221             {
4222               do_debugging = 0;
4223               dwarf_select_sections_by_names (optarg);
4224             }
4225           break;
4226         case OPTION_DWARF_DEPTH:
4227           {
4228             char *cp;
4229
4230             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4231           }
4232           break;
4233         case OPTION_DWARF_START:
4234           {
4235             char *cp;
4236
4237             dwarf_start_die = strtoul (optarg, & cp, 0);
4238           }
4239           break;
4240         case OPTION_DWARF_CHECK:
4241           dwarf_check = 1;
4242           break;
4243         case OPTION_DYN_SYMS:
4244           do_dyn_syms++;
4245           break;
4246 #ifdef SUPPORT_DISASSEMBLY
4247         case 'i':
4248           request_dump (DISASS_DUMP);
4249           break;
4250 #endif
4251         case 'v':
4252           print_version (program_name);
4253           break;
4254         case 'V':
4255           do_version++;
4256           break;
4257         case 'W':
4258           do_wide++;
4259           break;
4260         default:
4261           /* xgettext:c-format */
4262           error (_("Invalid option '-%c'\n"), c);
4263           /* Drop through.  */
4264         case '?':
4265           usage (stderr);
4266         }
4267     }
4268
4269   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4270       && !do_segments && !do_header && !do_dump && !do_version
4271       && !do_histogram && !do_debugging && !do_arch && !do_notes
4272       && !do_section_groups && !do_archive_index
4273       && !do_dyn_syms)
4274     usage (stderr);
4275 }
4276
4277 static const char *
4278 get_elf_class (unsigned int elf_class)
4279 {
4280   static char buff[32];
4281
4282   switch (elf_class)
4283     {
4284     case ELFCLASSNONE: return _("none");
4285     case ELFCLASS32:   return "ELF32";
4286     case ELFCLASS64:   return "ELF64";
4287     default:
4288       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4289       return buff;
4290     }
4291 }
4292
4293 static const char *
4294 get_data_encoding (unsigned int encoding)
4295 {
4296   static char buff[32];
4297
4298   switch (encoding)
4299     {
4300     case ELFDATANONE: return _("none");
4301     case ELFDATA2LSB: return _("2's complement, little endian");
4302     case ELFDATA2MSB: return _("2's complement, big endian");
4303     default:
4304       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4305       return buff;
4306     }
4307 }
4308
4309 /* Decode the data held in 'elf_header'.  */
4310
4311 static int
4312 process_file_header (void)
4313 {
4314   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4315       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4316       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4317       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4318     {
4319       error
4320         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4321       return 0;
4322     }
4323
4324   init_dwarf_regnames (elf_header.e_machine);
4325
4326   if (do_header)
4327     {
4328       int i;
4329
4330       printf (_("ELF Header:\n"));
4331       printf (_("  Magic:   "));
4332       for (i = 0; i < EI_NIDENT; i++)
4333         printf ("%2.2x ", elf_header.e_ident[i]);
4334       printf ("\n");
4335       printf (_("  Class:                             %s\n"),
4336               get_elf_class (elf_header.e_ident[EI_CLASS]));
4337       printf (_("  Data:                              %s\n"),
4338               get_data_encoding (elf_header.e_ident[EI_DATA]));
4339       printf (_("  Version:                           %d %s\n"),
4340               elf_header.e_ident[EI_VERSION],
4341               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4342                ? "(current)"
4343                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4344                   ? _("<unknown: %lx>")
4345                   : "")));
4346       printf (_("  OS/ABI:                            %s\n"),
4347               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4348       printf (_("  ABI Version:                       %d\n"),
4349               elf_header.e_ident[EI_ABIVERSION]);
4350       printf (_("  Type:                              %s\n"),
4351               get_file_type (elf_header.e_type));
4352       printf (_("  Machine:                           %s\n"),
4353               get_machine_name (elf_header.e_machine));
4354       printf (_("  Version:                           0x%lx\n"),
4355               (unsigned long) elf_header.e_version);
4356
4357       printf (_("  Entry point address:               "));
4358       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4359       printf (_("\n  Start of program headers:          "));
4360       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4361       printf (_(" (bytes into file)\n  Start of section headers:          "));
4362       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4363       printf (_(" (bytes into file)\n"));
4364
4365       printf (_("  Flags:                             0x%lx%s\n"),
4366               (unsigned long) elf_header.e_flags,
4367               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4368       printf (_("  Size of this header:               %ld (bytes)\n"),
4369               (long) elf_header.e_ehsize);
4370       printf (_("  Size of program headers:           %ld (bytes)\n"),
4371               (long) elf_header.e_phentsize);
4372       printf (_("  Number of program headers:         %ld"),
4373               (long) elf_header.e_phnum);
4374       if (section_headers != NULL
4375           && elf_header.e_phnum == PN_XNUM
4376           && section_headers[0].sh_info != 0)
4377         printf (" (%ld)", (long) section_headers[0].sh_info);
4378       putc ('\n', stdout);
4379       printf (_("  Size of section headers:           %ld (bytes)\n"),
4380               (long) elf_header.e_shentsize);
4381       printf (_("  Number of section headers:         %ld"),
4382               (long) elf_header.e_shnum);
4383       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4384         printf (" (%ld)", (long) section_headers[0].sh_size);
4385       putc ('\n', stdout);
4386       printf (_("  Section header string table index: %ld"),
4387               (long) elf_header.e_shstrndx);
4388       if (section_headers != NULL
4389           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4390         printf (" (%u)", section_headers[0].sh_link);
4391       else if (elf_header.e_shstrndx != SHN_UNDEF
4392                && elf_header.e_shstrndx >= elf_header.e_shnum)
4393         printf (_(" <corrupt: out of range>"));
4394       putc ('\n', stdout);
4395     }
4396
4397   if (section_headers != NULL)
4398     {
4399       if (elf_header.e_phnum == PN_XNUM
4400           && section_headers[0].sh_info != 0)
4401         elf_header.e_phnum = section_headers[0].sh_info;
4402       if (elf_header.e_shnum == SHN_UNDEF)
4403         elf_header.e_shnum = section_headers[0].sh_size;
4404       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4405         elf_header.e_shstrndx = section_headers[0].sh_link;
4406       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4407         elf_header.e_shstrndx = SHN_UNDEF;
4408       free (section_headers);
4409       section_headers = NULL;
4410     }
4411
4412   return 1;
4413 }
4414
4415 static bfd_boolean
4416 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4417 {
4418   Elf32_External_Phdr * phdrs;
4419   Elf32_External_Phdr * external;
4420   Elf_Internal_Phdr *   internal;
4421   unsigned int i;
4422   unsigned int size = elf_header.e_phentsize;
4423   unsigned int num  = elf_header.e_phnum;
4424
4425   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4426   if (size == 0 || num == 0)
4427     return FALSE;
4428   if (size < sizeof * phdrs)
4429     {
4430       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4431       return FALSE;
4432     }
4433   if (size > sizeof * phdrs)
4434     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4435
4436   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4437                                             size, num, _("program headers"));
4438   if (phdrs == NULL)
4439     return FALSE;
4440
4441   for (i = 0, internal = pheaders, external = phdrs;
4442        i < elf_header.e_phnum;
4443        i++, internal++, external++)
4444     {
4445       internal->p_type   = BYTE_GET (external->p_type);
4446       internal->p_offset = BYTE_GET (external->p_offset);
4447       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4448       internal->p_paddr  = BYTE_GET (external->p_paddr);
4449       internal->p_filesz = BYTE_GET (external->p_filesz);
4450       internal->p_memsz  = BYTE_GET (external->p_memsz);
4451       internal->p_flags  = BYTE_GET (external->p_flags);
4452       internal->p_align  = BYTE_GET (external->p_align);
4453     }
4454
4455   free (phdrs);
4456   return TRUE;
4457 }
4458
4459 static bfd_boolean
4460 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4461 {
4462   Elf64_External_Phdr * phdrs;
4463   Elf64_External_Phdr * external;
4464   Elf_Internal_Phdr *   internal;
4465   unsigned int i;
4466   unsigned int size = elf_header.e_phentsize;
4467   unsigned int num  = elf_header.e_phnum;
4468
4469   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4470   if (size == 0 || num == 0)
4471     return FALSE;
4472   if (size < sizeof * phdrs)
4473     {
4474       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4475       return FALSE;
4476     }
4477   if (size > sizeof * phdrs)
4478     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4479
4480   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4481                                             size, num, _("program headers"));
4482   if (!phdrs)
4483     return FALSE;
4484
4485   for (i = 0, internal = pheaders, external = phdrs;
4486        i < elf_header.e_phnum;
4487        i++, internal++, external++)
4488     {
4489       internal->p_type   = BYTE_GET (external->p_type);
4490       internal->p_flags  = BYTE_GET (external->p_flags);
4491       internal->p_offset = BYTE_GET (external->p_offset);
4492       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4493       internal->p_paddr  = BYTE_GET (external->p_paddr);
4494       internal->p_filesz = BYTE_GET (external->p_filesz);
4495       internal->p_memsz  = BYTE_GET (external->p_memsz);
4496       internal->p_align  = BYTE_GET (external->p_align);
4497     }
4498
4499   free (phdrs);
4500   return TRUE;
4501 }
4502
4503 /* Returns 1 if the program headers were read into `program_headers'.  */
4504
4505 static int
4506 get_program_headers (FILE * file)
4507 {
4508   Elf_Internal_Phdr * phdrs;
4509
4510   /* Check cache of prior read.  */
4511   if (program_headers != NULL)
4512     return 1;
4513
4514   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4515                                          sizeof (Elf_Internal_Phdr));
4516
4517   if (phdrs == NULL)
4518     {
4519       error (_("Out of memory reading %u program headers\n"),
4520              elf_header.e_phnum);
4521       return 0;
4522     }
4523
4524   if (is_32bit_elf
4525       ? get_32bit_program_headers (file, phdrs)
4526       : get_64bit_program_headers (file, phdrs))
4527     {
4528       program_headers = phdrs;
4529       return 1;
4530     }
4531
4532   free (phdrs);
4533   return 0;
4534 }
4535
4536 /* Returns 1 if the program headers were loaded.  */
4537
4538 static int
4539 process_program_headers (FILE * file)
4540 {
4541   Elf_Internal_Phdr * segment;
4542   unsigned int i;
4543
4544   if (elf_header.e_phnum == 0)
4545     {
4546       /* PR binutils/12467.  */
4547       if (elf_header.e_phoff != 0)
4548         warn (_("possibly corrupt ELF header - it has a non-zero program"
4549                 " header offset, but no program headers\n"));
4550       else if (do_segments)
4551         printf (_("\nThere are no program headers in this file.\n"));
4552       return 0;
4553     }
4554
4555   if (do_segments && !do_header)
4556     {
4557       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4558       printf (_("Entry point "));
4559       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4560       printf (_("\nThere are %d program headers, starting at offset "),
4561               elf_header.e_phnum);
4562       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4563       printf ("\n");
4564     }
4565
4566   if (! get_program_headers (file))
4567       return 0;
4568
4569   if (do_segments)
4570     {
4571       if (elf_header.e_phnum > 1)
4572         printf (_("\nProgram Headers:\n"));
4573       else
4574         printf (_("\nProgram Headers:\n"));
4575
4576       if (is_32bit_elf)
4577         printf
4578           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4579       else if (do_wide)
4580         printf
4581           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4582       else
4583         {
4584           printf
4585             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4586           printf
4587             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4588         }
4589     }
4590
4591   dynamic_addr = 0;
4592   dynamic_size = 0;
4593
4594   for (i = 0, segment = program_headers;
4595        i < elf_header.e_phnum;
4596        i++, segment++)
4597     {
4598       if (do_segments)
4599         {
4600           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4601
4602           if (is_32bit_elf)
4603             {
4604               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4605               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4606               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4607               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4608               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4609               printf ("%c%c%c ",
4610                       (segment->p_flags & PF_R ? 'R' : ' '),
4611                       (segment->p_flags & PF_W ? 'W' : ' '),
4612                       (segment->p_flags & PF_X ? 'E' : ' '));
4613               printf ("%#lx", (unsigned long) segment->p_align);
4614             }
4615           else if (do_wide)
4616             {
4617               if ((unsigned long) segment->p_offset == segment->p_offset)
4618                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4619               else
4620                 {
4621                   print_vma (segment->p_offset, FULL_HEX);
4622                   putchar (' ');
4623                 }
4624
4625               print_vma (segment->p_vaddr, FULL_HEX);
4626               putchar (' ');
4627               print_vma (segment->p_paddr, FULL_HEX);
4628               putchar (' ');
4629
4630               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4631                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4632               else
4633                 {
4634                   print_vma (segment->p_filesz, FULL_HEX);
4635                   putchar (' ');
4636                 }
4637
4638               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4639                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4640               else
4641                 {
4642                   print_vma (segment->p_memsz, FULL_HEX);
4643                 }
4644
4645               printf (" %c%c%c ",
4646                       (segment->p_flags & PF_R ? 'R' : ' '),
4647                       (segment->p_flags & PF_W ? 'W' : ' '),
4648                       (segment->p_flags & PF_X ? 'E' : ' '));
4649
4650               if ((unsigned long) segment->p_align == segment->p_align)
4651                 printf ("%#lx", (unsigned long) segment->p_align);
4652               else
4653                 {
4654                   print_vma (segment->p_align, PREFIX_HEX);
4655                 }
4656             }
4657           else
4658             {
4659               print_vma (segment->p_offset, FULL_HEX);
4660               putchar (' ');
4661               print_vma (segment->p_vaddr, FULL_HEX);
4662               putchar (' ');
4663               print_vma (segment->p_paddr, FULL_HEX);
4664               printf ("\n                 ");
4665               print_vma (segment->p_filesz, FULL_HEX);
4666               putchar (' ');
4667               print_vma (segment->p_memsz, FULL_HEX);
4668               printf ("  %c%c%c    ",
4669                       (segment->p_flags & PF_R ? 'R' : ' '),
4670                       (segment->p_flags & PF_W ? 'W' : ' '),
4671                       (segment->p_flags & PF_X ? 'E' : ' '));
4672               print_vma (segment->p_align, HEX);
4673             }
4674         }
4675
4676       if (do_segments)
4677         putc ('\n', stdout);
4678
4679       switch (segment->p_type)
4680         {
4681         case PT_DYNAMIC:
4682           if (dynamic_addr)
4683             error (_("more than one dynamic segment\n"));
4684
4685           /* By default, assume that the .dynamic section is the first
4686              section in the DYNAMIC segment.  */
4687           dynamic_addr = segment->p_offset;
4688           dynamic_size = segment->p_filesz;
4689           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4690           if (dynamic_addr + dynamic_size >= current_file_size)
4691             {
4692               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4693               dynamic_addr = dynamic_size = 0;
4694             }
4695
4696           /* Try to locate the .dynamic section. If there is
4697              a section header table, we can easily locate it.  */
4698           if (section_headers != NULL)
4699             {
4700               Elf_Internal_Shdr * sec;
4701
4702               sec = find_section (".dynamic");
4703               if (sec == NULL || sec->sh_size == 0)
4704                 {
4705                   /* A corresponding .dynamic section is expected, but on
4706                      IA-64/OpenVMS it is OK for it to be missing.  */
4707                   if (!is_ia64_vms ())
4708                     error (_("no .dynamic section in the dynamic segment\n"));
4709                   break;
4710                 }
4711
4712               if (sec->sh_type == SHT_NOBITS)
4713                 {
4714                   dynamic_size = 0;
4715                   break;
4716                 }
4717
4718               dynamic_addr = sec->sh_offset;
4719               dynamic_size = sec->sh_size;
4720
4721               if (dynamic_addr < segment->p_offset
4722                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4723                 warn (_("the .dynamic section is not contained"
4724                         " within the dynamic segment\n"));
4725               else if (dynamic_addr > segment->p_offset)
4726                 warn (_("the .dynamic section is not the first section"
4727                         " in the dynamic segment.\n"));
4728             }
4729           break;
4730
4731         case PT_INTERP:
4732           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4733                      SEEK_SET))
4734             error (_("Unable to find program interpreter name\n"));
4735           else
4736             {
4737               char fmt [32];
4738               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4739
4740               if (ret >= (int) sizeof (fmt) || ret < 0)
4741                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4742
4743               program_interpreter[0] = 0;
4744               if (fscanf (file, fmt, program_interpreter) <= 0)
4745                 error (_("Unable to read program interpreter name\n"));
4746
4747               if (do_segments)
4748                 printf (_("      [Requesting program interpreter: %s]\n"),
4749                     program_interpreter);
4750             }
4751           break;
4752         }
4753     }
4754
4755   if (do_segments && section_headers != NULL && string_table != NULL)
4756     {
4757       printf (_("\n Section to Segment mapping:\n"));
4758       printf (_("  Segment Sections...\n"));
4759
4760       for (i = 0; i < elf_header.e_phnum; i++)
4761         {
4762           unsigned int j;
4763           Elf_Internal_Shdr * section;
4764
4765           segment = program_headers + i;
4766           section = section_headers + 1;
4767
4768           printf ("   %2.2d     ", i);
4769
4770           for (j = 1; j < elf_header.e_shnum; j++, section++)
4771             {
4772               if (!ELF_TBSS_SPECIAL (section, segment)
4773                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4774                 printf ("%s ", printable_section_name (section));
4775             }
4776
4777           putc ('\n',stdout);
4778         }
4779     }
4780
4781   return 1;
4782 }
4783
4784
4785 /* Find the file offset corresponding to VMA by using the program headers.  */
4786
4787 static long
4788 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4789 {
4790   Elf_Internal_Phdr * seg;
4791
4792   if (! get_program_headers (file))
4793     {
4794       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4795       return (long) vma;
4796     }
4797
4798   for (seg = program_headers;
4799        seg < program_headers + elf_header.e_phnum;
4800        ++seg)
4801     {
4802       if (seg->p_type != PT_LOAD)
4803         continue;
4804
4805       if (vma >= (seg->p_vaddr & -seg->p_align)
4806           && vma + size <= seg->p_vaddr + seg->p_filesz)
4807         return vma - seg->p_vaddr + seg->p_offset;
4808     }
4809
4810   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4811         (unsigned long) vma);
4812   return (long) vma;
4813 }
4814
4815
4816 /* Allocate memory and load the sections headers into the global pointer
4817    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4818    generate any error messages if the load fails.  */
4819
4820 static bfd_boolean
4821 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4822 {
4823   Elf32_External_Shdr * shdrs;
4824   Elf_Internal_Shdr *   internal;
4825   unsigned int i;
4826   unsigned int size = elf_header.e_shentsize;
4827   unsigned int num = probe ? 1 : elf_header.e_shnum;
4828
4829   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4830   if (size == 0 || num == 0)
4831     return FALSE;
4832   if (size < sizeof * shdrs)
4833     {
4834       if (! probe)
4835         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4836       return FALSE;
4837     }
4838   if (!probe && size > sizeof * shdrs)
4839     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4840
4841   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4842                                             size, num,
4843                                             probe ? NULL : _("section headers"));
4844   if (shdrs == NULL)
4845     return FALSE;
4846
4847   if (section_headers != NULL)
4848     free (section_headers);
4849   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4850                                                    sizeof (Elf_Internal_Shdr));
4851   if (section_headers == NULL)
4852     {
4853       if (!probe)
4854         error (_("Out of memory reading %u section headers\n"), num);
4855       return FALSE;
4856     }
4857
4858   for (i = 0, internal = section_headers;
4859        i < num;
4860        i++, internal++)
4861     {
4862       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4863       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4864       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4865       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4866       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4867       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4868       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4869       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4870       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4871       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4872     }
4873
4874   free (shdrs);
4875   return TRUE;
4876 }
4877
4878 static bfd_boolean
4879 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4880 {
4881   Elf64_External_Shdr * shdrs;
4882   Elf_Internal_Shdr *   internal;
4883   unsigned int i;
4884   unsigned int size = elf_header.e_shentsize;
4885   unsigned int num = probe ? 1 : elf_header.e_shnum;
4886
4887   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4888   if (size == 0 || num == 0)
4889     return FALSE;
4890   if (size < sizeof * shdrs)
4891     {
4892       if (! probe)
4893         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4894       return FALSE;
4895     }
4896   if (! probe && size > sizeof * shdrs)
4897     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4898
4899   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4900                                             size, num,
4901                                             probe ? NULL : _("section headers"));
4902   if (shdrs == NULL)
4903     return FALSE;
4904
4905   if (section_headers != NULL)
4906     free (section_headers);
4907   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4908                                                    sizeof (Elf_Internal_Shdr));
4909   if (section_headers == NULL)
4910     {
4911       if (! probe)
4912         error (_("Out of memory reading %u section headers\n"), num);
4913       return FALSE;
4914     }
4915
4916   for (i = 0, internal = section_headers;
4917        i < num;
4918        i++, internal++)
4919     {
4920       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4921       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4922       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4923       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4924       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4925       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4926       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4927       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4928       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4929       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4930     }
4931
4932   free (shdrs);
4933   return TRUE;
4934 }
4935
4936 static Elf_Internal_Sym *
4937 get_32bit_elf_symbols (FILE * file,
4938                        Elf_Internal_Shdr * section,
4939                        unsigned long * num_syms_return)
4940 {
4941   unsigned long number = 0;
4942   Elf32_External_Sym * esyms = NULL;
4943   Elf_External_Sym_Shndx * shndx = NULL;
4944   Elf_Internal_Sym * isyms = NULL;
4945   Elf_Internal_Sym * psym;
4946   unsigned int j;
4947
4948   if (section->sh_size == 0)
4949     {
4950       if (num_syms_return != NULL)
4951         * num_syms_return = 0;
4952       return NULL;
4953     }
4954
4955   /* Run some sanity checks first.  */
4956   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4957     {
4958       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4959              printable_section_name (section), (unsigned long) section->sh_entsize);
4960       goto exit_point;
4961     }
4962
4963   if (section->sh_size > current_file_size)
4964     {
4965       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4966              printable_section_name (section), (unsigned long) section->sh_size);
4967       goto exit_point;
4968     }
4969
4970   number = section->sh_size / section->sh_entsize;
4971
4972   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4973     {
4974       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4975              (unsigned long) section->sh_size,
4976              printable_section_name (section),
4977              (unsigned long) section->sh_entsize);
4978       goto exit_point;
4979     }
4980
4981   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4982                                            section->sh_size, _("symbols"));
4983   if (esyms == NULL)
4984     goto exit_point;
4985
4986   shndx = NULL;
4987   if (symtab_shndx_hdr != NULL
4988       && (symtab_shndx_hdr->sh_link
4989           == (unsigned long) (section - section_headers)))
4990     {
4991       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4992                                                    symtab_shndx_hdr->sh_offset,
4993                                                    1, symtab_shndx_hdr->sh_size,
4994                                                    _("symbol table section indicies"));
4995       if (shndx == NULL)
4996         goto exit_point;
4997       /* PR17531: file: heap-buffer-overflow */
4998       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4999         {
5000           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5001                  printable_section_name (symtab_shndx_hdr),
5002                  (unsigned long) symtab_shndx_hdr->sh_size,
5003                  (unsigned long) section->sh_size);
5004           goto exit_point;
5005         }
5006     }
5007
5008   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5009
5010   if (isyms == NULL)
5011     {
5012       error (_("Out of memory reading %lu symbols\n"),
5013              (unsigned long) number);
5014       goto exit_point;
5015     }
5016
5017   for (j = 0, psym = isyms; j < number; j++, psym++)
5018     {
5019       psym->st_name  = BYTE_GET (esyms[j].st_name);
5020       psym->st_value = BYTE_GET (esyms[j].st_value);
5021       psym->st_size  = BYTE_GET (esyms[j].st_size);
5022       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5023       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5024         psym->st_shndx
5025           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5026       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5027         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5028       psym->st_info  = BYTE_GET (esyms[j].st_info);
5029       psym->st_other = BYTE_GET (esyms[j].st_other);
5030     }
5031
5032  exit_point:
5033   if (shndx != NULL)
5034     free (shndx);
5035   if (esyms != NULL)
5036     free (esyms);
5037
5038   if (num_syms_return != NULL)
5039     * num_syms_return = isyms == NULL ? 0 : number;
5040
5041   return isyms;
5042 }
5043
5044 static Elf_Internal_Sym *
5045 get_64bit_elf_symbols (FILE * file,
5046                        Elf_Internal_Shdr * section,
5047                        unsigned long * num_syms_return)
5048 {
5049   unsigned long number = 0;
5050   Elf64_External_Sym * esyms = NULL;
5051   Elf_External_Sym_Shndx * shndx = NULL;
5052   Elf_Internal_Sym * isyms = NULL;
5053   Elf_Internal_Sym * psym;
5054   unsigned int j;
5055
5056   if (section->sh_size == 0)
5057     {
5058       if (num_syms_return != NULL)
5059         * num_syms_return = 0;
5060       return NULL;
5061     }
5062
5063   /* Run some sanity checks first.  */
5064   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5065     {
5066       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5067              printable_section_name (section),
5068              (unsigned long) section->sh_entsize);
5069       goto exit_point;
5070     }
5071
5072   if (section->sh_size > current_file_size)
5073     {
5074       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5075              printable_section_name (section),
5076              (unsigned long) section->sh_size);
5077       goto exit_point;
5078     }
5079
5080   number = section->sh_size / section->sh_entsize;
5081
5082   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5083     {
5084       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5085              (unsigned long) section->sh_size,
5086              printable_section_name (section),
5087              (unsigned long) section->sh_entsize);
5088       goto exit_point;
5089     }
5090
5091   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5092                                            section->sh_size, _("symbols"));
5093   if (!esyms)
5094     goto exit_point;
5095
5096   if (symtab_shndx_hdr != NULL
5097       && (symtab_shndx_hdr->sh_link
5098           == (unsigned long) (section - section_headers)))
5099     {
5100       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5101                                                    symtab_shndx_hdr->sh_offset,
5102                                                    1, symtab_shndx_hdr->sh_size,
5103                                                    _("symbol table section indicies"));
5104       if (shndx == NULL)
5105         goto exit_point;
5106       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5107         {
5108           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5109                  printable_section_name (symtab_shndx_hdr),
5110                  (unsigned long) symtab_shndx_hdr->sh_size,
5111                  (unsigned long) section->sh_size);
5112           goto exit_point;
5113         }
5114     }
5115
5116   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5117
5118   if (isyms == NULL)
5119     {
5120       error (_("Out of memory reading %lu symbols\n"),
5121              (unsigned long) number);
5122       goto exit_point;
5123     }
5124
5125   for (j = 0, psym = isyms; j < number; j++, psym++)
5126     {
5127       psym->st_name  = BYTE_GET (esyms[j].st_name);
5128       psym->st_info  = BYTE_GET (esyms[j].st_info);
5129       psym->st_other = BYTE_GET (esyms[j].st_other);
5130       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5131
5132       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5133         psym->st_shndx
5134           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5135       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5136         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5137
5138       psym->st_value = BYTE_GET (esyms[j].st_value);
5139       psym->st_size  = BYTE_GET (esyms[j].st_size);
5140     }
5141
5142  exit_point:
5143   if (shndx != NULL)
5144     free (shndx);
5145   if (esyms != NULL)
5146     free (esyms);
5147
5148   if (num_syms_return != NULL)
5149     * num_syms_return = isyms == NULL ? 0 : number;
5150
5151   return isyms;
5152 }
5153
5154 static const char *
5155 get_elf_section_flags (bfd_vma sh_flags)
5156 {
5157   static char buff[1024];
5158   char * p = buff;
5159   int field_size = is_32bit_elf ? 8 : 16;
5160   int sindex;
5161   int size = sizeof (buff) - (field_size + 4 + 1);
5162   bfd_vma os_flags = 0;
5163   bfd_vma proc_flags = 0;
5164   bfd_vma unknown_flags = 0;
5165   static const struct
5166     {
5167       const char * str;
5168       int len;
5169     }
5170   flags [] =
5171     {
5172       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5173       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5174       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5175       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5176       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5177       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5178       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5179       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5180       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5181       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5182       /* IA-64 specific.  */
5183       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5184       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5185       /* IA-64 OpenVMS specific.  */
5186       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5187       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5188       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5189       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5190       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5191       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5192       /* Generic.  */
5193       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5194       /* SPARC specific.  */
5195       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5196       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5197     };
5198
5199   if (do_section_details)
5200     {
5201       sprintf (buff, "[%*.*lx]: ",
5202                field_size, field_size, (unsigned long) sh_flags);
5203       p += field_size + 4;
5204     }
5205
5206   while (sh_flags)
5207     {
5208       bfd_vma flag;
5209
5210       flag = sh_flags & - sh_flags;
5211       sh_flags &= ~ flag;
5212
5213       if (do_section_details)
5214         {
5215           switch (flag)
5216             {
5217             case SHF_WRITE:             sindex = 0; break;
5218             case SHF_ALLOC:             sindex = 1; break;
5219             case SHF_EXECINSTR:         sindex = 2; break;
5220             case SHF_MERGE:             sindex = 3; break;
5221             case SHF_STRINGS:           sindex = 4; break;
5222             case SHF_INFO_LINK:         sindex = 5; break;
5223             case SHF_LINK_ORDER:        sindex = 6; break;
5224             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5225             case SHF_GROUP:             sindex = 8; break;
5226             case SHF_TLS:               sindex = 9; break;
5227             case SHF_EXCLUDE:           sindex = 18; break;
5228             case SHF_COMPRESSED:        sindex = 20; break;
5229
5230             default:
5231               sindex = -1;
5232               switch (elf_header.e_machine)
5233                 {
5234                 case EM_IA_64:
5235                   if (flag == SHF_IA_64_SHORT)
5236                     sindex = 10;
5237                   else if (flag == SHF_IA_64_NORECOV)
5238                     sindex = 11;
5239 #ifdef BFD64
5240                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5241                     switch (flag)
5242                       {
5243                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5244                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5245                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5246                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5247                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5248                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5249                       default:                        break;
5250                       }
5251 #endif
5252                   break;
5253
5254                 case EM_386:
5255                 case EM_IAMCU:
5256                 case EM_X86_64:
5257                 case EM_L1OM:
5258                 case EM_K1OM:
5259                 case EM_OLD_SPARCV9:
5260                 case EM_SPARC32PLUS:
5261                 case EM_SPARCV9:
5262                 case EM_SPARC:
5263                   if (flag == SHF_ORDERED)
5264                     sindex = 19;
5265                   break;
5266                 default:
5267                   break;
5268                 }
5269             }
5270
5271           if (sindex != -1)
5272             {
5273               if (p != buff + field_size + 4)
5274                 {
5275                   if (size < (10 + 2))
5276                     {
5277                       warn (_("Internal error: not enough buffer room for section flag info"));
5278                       return _("<unknown>");
5279                     }
5280                   size -= 2;
5281                   *p++ = ',';
5282                   *p++ = ' ';
5283                 }
5284
5285               size -= flags [sindex].len;
5286               p = stpcpy (p, flags [sindex].str);
5287             }
5288           else if (flag & SHF_MASKOS)
5289             os_flags |= flag;
5290           else if (flag & SHF_MASKPROC)
5291             proc_flags |= flag;
5292           else
5293             unknown_flags |= flag;
5294         }
5295       else
5296         {
5297           switch (flag)
5298             {
5299             case SHF_WRITE:             *p = 'W'; break;
5300             case SHF_ALLOC:             *p = 'A'; break;
5301             case SHF_EXECINSTR:         *p = 'X'; break;
5302             case SHF_MERGE:             *p = 'M'; break;
5303             case SHF_STRINGS:           *p = 'S'; break;
5304             case SHF_INFO_LINK:         *p = 'I'; break;
5305             case SHF_LINK_ORDER:        *p = 'L'; break;
5306             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5307             case SHF_GROUP:             *p = 'G'; break;
5308             case SHF_TLS:               *p = 'T'; break;
5309             case SHF_EXCLUDE:           *p = 'E'; break;
5310             case SHF_COMPRESSED:        *p = 'C'; break;
5311
5312             default:
5313               if ((elf_header.e_machine == EM_X86_64
5314                    || elf_header.e_machine == EM_L1OM
5315                    || elf_header.e_machine == EM_K1OM)
5316                   && flag == SHF_X86_64_LARGE)
5317                 *p = 'l';
5318               else if (flag & SHF_MASKOS)
5319                 {
5320                   *p = 'o';
5321                   sh_flags &= ~ SHF_MASKOS;
5322                 }
5323               else if (flag & SHF_MASKPROC)
5324                 {
5325                   *p = 'p';
5326                   sh_flags &= ~ SHF_MASKPROC;
5327                 }
5328               else
5329                 *p = 'x';
5330               break;
5331             }
5332           p++;
5333         }
5334     }
5335
5336   if (do_section_details)
5337     {
5338       if (os_flags)
5339         {
5340           size -= 5 + field_size;
5341           if (p != buff + field_size + 4)
5342             {
5343               if (size < (2 + 1))
5344                 {
5345                   warn (_("Internal error: not enough buffer room for section flag info"));
5346                   return _("<unknown>");
5347                 }
5348               size -= 2;
5349               *p++ = ',';
5350               *p++ = ' ';
5351             }
5352           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5353                    (unsigned long) os_flags);
5354           p += 5 + field_size;
5355         }
5356       if (proc_flags)
5357         {
5358           size -= 7 + field_size;
5359           if (p != buff + field_size + 4)
5360             {
5361               if (size < (2 + 1))
5362                 {
5363                   warn (_("Internal error: not enough buffer room for section flag info"));
5364                   return _("<unknown>");
5365                 }
5366               size -= 2;
5367               *p++ = ',';
5368               *p++ = ' ';
5369             }
5370           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5371                    (unsigned long) proc_flags);
5372           p += 7 + field_size;
5373         }
5374       if (unknown_flags)
5375         {
5376           size -= 10 + field_size;
5377           if (p != buff + field_size + 4)
5378             {
5379               if (size < (2 + 1))
5380                 {
5381                   warn (_("Internal error: not enough buffer room for section flag info"));
5382                   return _("<unknown>");
5383                 }
5384               size -= 2;
5385               *p++ = ',';
5386               *p++ = ' ';
5387             }
5388           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5389                    (unsigned long) unknown_flags);
5390           p += 10 + field_size;
5391         }
5392     }
5393
5394   *p = '\0';
5395   return buff;
5396 }
5397
5398 static unsigned int
5399 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5400 {
5401   if (is_32bit_elf)
5402     {
5403       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5404       chdr->ch_type = BYTE_GET (echdr->ch_type);
5405       chdr->ch_size = BYTE_GET (echdr->ch_size);
5406       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5407       return sizeof (*echdr);
5408     }
5409   else
5410     {
5411       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5412       chdr->ch_type = BYTE_GET (echdr->ch_type);
5413       chdr->ch_size = BYTE_GET (echdr->ch_size);
5414       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5415       return sizeof (*echdr);
5416     }
5417 }
5418
5419 static int
5420 process_section_headers (FILE * file)
5421 {
5422   Elf_Internal_Shdr * section;
5423   unsigned int i;
5424
5425   section_headers = NULL;
5426
5427   if (elf_header.e_shnum == 0)
5428     {
5429       /* PR binutils/12467.  */
5430       if (elf_header.e_shoff != 0)
5431         warn (_("possibly corrupt ELF file header - it has a non-zero"
5432                 " section header offset, but no section headers\n"));
5433       else if (do_sections)
5434         printf (_("\nThere are no sections in this file.\n"));
5435
5436       return 1;
5437     }
5438
5439   if (do_sections && !do_header)
5440     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5441             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5442
5443   if (is_32bit_elf)
5444     {
5445       if (! get_32bit_section_headers (file, FALSE))
5446         return 0;
5447     }
5448   else if (! get_64bit_section_headers (file, FALSE))
5449     return 0;
5450
5451   /* Read in the string table, so that we have names to display.  */
5452   if (elf_header.e_shstrndx != SHN_UNDEF
5453        && elf_header.e_shstrndx < elf_header.e_shnum)
5454     {
5455       section = section_headers + elf_header.e_shstrndx;
5456
5457       if (section->sh_size != 0)
5458         {
5459           string_table = (char *) get_data (NULL, file, section->sh_offset,
5460                                             1, section->sh_size,
5461                                             _("string table"));
5462
5463           string_table_length = string_table != NULL ? section->sh_size : 0;
5464         }
5465     }
5466
5467   /* Scan the sections for the dynamic symbol table
5468      and dynamic string table and debug sections.  */
5469   dynamic_symbols = NULL;
5470   dynamic_strings = NULL;
5471   dynamic_syminfo = NULL;
5472   symtab_shndx_hdr = NULL;
5473
5474   eh_addr_size = is_32bit_elf ? 4 : 8;
5475   switch (elf_header.e_machine)
5476     {
5477     case EM_MIPS:
5478     case EM_MIPS_RS3_LE:
5479       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5480          FDE addresses.  However, the ABI also has a semi-official ILP32
5481          variant for which the normal FDE address size rules apply.
5482
5483          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5484          section, where XX is the size of longs in bits.  Unfortunately,
5485          earlier compilers provided no way of distinguishing ILP32 objects
5486          from LP64 objects, so if there's any doubt, we should assume that
5487          the official LP64 form is being used.  */
5488       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5489           && find_section (".gcc_compiled_long32") == NULL)
5490         eh_addr_size = 8;
5491       break;
5492
5493     case EM_H8_300:
5494     case EM_H8_300H:
5495       switch (elf_header.e_flags & EF_H8_MACH)
5496         {
5497         case E_H8_MACH_H8300:
5498         case E_H8_MACH_H8300HN:
5499         case E_H8_MACH_H8300SN:
5500         case E_H8_MACH_H8300SXN:
5501           eh_addr_size = 2;
5502           break;
5503         case E_H8_MACH_H8300H:
5504         case E_H8_MACH_H8300S:
5505         case E_H8_MACH_H8300SX:
5506           eh_addr_size = 4;
5507           break;
5508         }
5509       break;
5510
5511     case EM_M32C_OLD:
5512     case EM_M32C:
5513       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5514         {
5515         case EF_M32C_CPU_M16C:
5516           eh_addr_size = 2;
5517           break;
5518         }
5519       break;
5520     }
5521
5522 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5523   do                                                                    \
5524     {                                                                   \
5525       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5526       if (section->sh_entsize != expected_entsize)                      \
5527         {                                                               \
5528           char buf[40];                                                 \
5529           sprintf_vma (buf, section->sh_entsize);                       \
5530           /* Note: coded this way so that there is a single string for  \
5531              translation.  */ \
5532           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5533           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5534                    (unsigned) expected_entsize);                        \
5535           section->sh_entsize = expected_entsize;                       \
5536         }                                                               \
5537     }                                                                   \
5538   while (0)
5539
5540 #define CHECK_ENTSIZE(section, i, type)                                 \
5541   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5542                         sizeof (Elf64_External_##type))
5543
5544   for (i = 0, section = section_headers;
5545        i < elf_header.e_shnum;
5546        i++, section++)
5547     {
5548       char * name = SECTION_NAME (section);
5549
5550       if (section->sh_type == SHT_DYNSYM)
5551         {
5552           if (dynamic_symbols != NULL)
5553             {
5554               error (_("File contains multiple dynamic symbol tables\n"));
5555               continue;
5556             }
5557
5558           CHECK_ENTSIZE (section, i, Sym);
5559           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5560         }
5561       else if (section->sh_type == SHT_STRTAB
5562                && streq (name, ".dynstr"))
5563         {
5564           if (dynamic_strings != NULL)
5565             {
5566               error (_("File contains multiple dynamic string tables\n"));
5567               continue;
5568             }
5569
5570           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5571                                                1, section->sh_size,
5572                                                _("dynamic strings"));
5573           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5574         }
5575       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5576         {
5577           if (symtab_shndx_hdr != NULL)
5578             {
5579               error (_("File contains multiple symtab shndx tables\n"));
5580               continue;
5581             }
5582           symtab_shndx_hdr = section;
5583         }
5584       else if (section->sh_type == SHT_SYMTAB)
5585         CHECK_ENTSIZE (section, i, Sym);
5586       else if (section->sh_type == SHT_GROUP)
5587         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5588       else if (section->sh_type == SHT_REL)
5589         CHECK_ENTSIZE (section, i, Rel);
5590       else if (section->sh_type == SHT_RELA)
5591         CHECK_ENTSIZE (section, i, Rela);
5592       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5593                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5594                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5595                 || do_debug_str || do_debug_loc || do_debug_ranges
5596                 || do_debug_addr || do_debug_cu_index)
5597                && (const_strneq (name, ".debug_")
5598                    || const_strneq (name, ".zdebug_")))
5599         {
5600           if (name[1] == 'z')
5601             name += sizeof (".zdebug_") - 1;
5602           else
5603             name += sizeof (".debug_") - 1;
5604
5605           if (do_debugging
5606               || (do_debug_info     && const_strneq (name, "info"))
5607               || (do_debug_info     && const_strneq (name, "types"))
5608               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5609               || (do_debug_lines    && strcmp (name, "line") == 0)
5610               || (do_debug_lines    && const_strneq (name, "line."))
5611               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5612               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5613               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5614               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5615               || (do_debug_aranges  && const_strneq (name, "aranges"))
5616               || (do_debug_ranges   && const_strneq (name, "ranges"))
5617               || (do_debug_frames   && const_strneq (name, "frame"))
5618               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5619               || (do_debug_macinfo  && const_strneq (name, "macro"))
5620               || (do_debug_str      && const_strneq (name, "str"))
5621               || (do_debug_loc      && const_strneq (name, "loc"))
5622               || (do_debug_addr     && const_strneq (name, "addr"))
5623               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5624               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5625               )
5626             request_dump_bynumber (i, DEBUG_DUMP);
5627         }
5628       /* Linkonce section to be combined with .debug_info at link time.  */
5629       else if ((do_debugging || do_debug_info)
5630                && const_strneq (name, ".gnu.linkonce.wi."))
5631         request_dump_bynumber (i, DEBUG_DUMP);
5632       else if (do_debug_frames && streq (name, ".eh_frame"))
5633         request_dump_bynumber (i, DEBUG_DUMP);
5634       else if (do_gdb_index && streq (name, ".gdb_index"))
5635         request_dump_bynumber (i, DEBUG_DUMP);
5636       /* Trace sections for Itanium VMS.  */
5637       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5638                 || do_trace_aranges)
5639                && const_strneq (name, ".trace_"))
5640         {
5641           name += sizeof (".trace_") - 1;
5642
5643           if (do_debugging
5644               || (do_trace_info     && streq (name, "info"))
5645               || (do_trace_abbrevs  && streq (name, "abbrev"))
5646               || (do_trace_aranges  && streq (name, "aranges"))
5647               )
5648             request_dump_bynumber (i, DEBUG_DUMP);
5649         }
5650     }
5651
5652   if (! do_sections)
5653     return 1;
5654
5655   if (elf_header.e_shnum > 1)
5656     printf (_("\nSection Headers:\n"));
5657   else
5658     printf (_("\nSection Header:\n"));
5659
5660   if (is_32bit_elf)
5661     {
5662       if (do_section_details)
5663         {
5664           printf (_("  [Nr] Name\n"));
5665           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5666         }
5667       else
5668         printf
5669           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5670     }
5671   else if (do_wide)
5672     {
5673       if (do_section_details)
5674         {
5675           printf (_("  [Nr] Name\n"));
5676           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5677         }
5678       else
5679         printf
5680           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5681     }
5682   else
5683     {
5684       if (do_section_details)
5685         {
5686           printf (_("  [Nr] Name\n"));
5687           printf (_("       Type              Address          Offset            Link\n"));
5688           printf (_("       Size              EntSize          Info              Align\n"));
5689         }
5690       else
5691         {
5692           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5693           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5694         }
5695     }
5696
5697   if (do_section_details)
5698     printf (_("       Flags\n"));
5699
5700   for (i = 0, section = section_headers;
5701        i < elf_header.e_shnum;
5702        i++, section++)
5703     {
5704       printf ("  [%2u] ", i);
5705       if (do_section_details)
5706         printf ("%s\n      ", printable_section_name (section));
5707       else
5708         print_symbol (-17, SECTION_NAME (section));
5709
5710       printf (do_wide ? " %-15s " : " %-15.15s ",
5711               get_section_type_name (section->sh_type));
5712
5713       if (is_32bit_elf)
5714         {
5715           const char * link_too_big = NULL;
5716
5717           print_vma (section->sh_addr, LONG_HEX);
5718
5719           printf ( " %6.6lx %6.6lx %2.2lx",
5720                    (unsigned long) section->sh_offset,
5721                    (unsigned long) section->sh_size,
5722                    (unsigned long) section->sh_entsize);
5723
5724           if (do_section_details)
5725             fputs ("  ", stdout);
5726           else
5727             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5728
5729           if (section->sh_link >= elf_header.e_shnum)
5730             {
5731               link_too_big = "";
5732               /* The sh_link value is out of range.  Normally this indicates
5733                  an error but it can have special values in Solaris binaries.  */
5734               switch (elf_header.e_machine)
5735                 {
5736                 case EM_386:
5737                 case EM_IAMCU:
5738                 case EM_X86_64:
5739                 case EM_L1OM:
5740                 case EM_K1OM:
5741                 case EM_OLD_SPARCV9:
5742                 case EM_SPARC32PLUS:
5743                 case EM_SPARCV9:
5744                 case EM_SPARC:
5745                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5746                     link_too_big = "BEFORE";
5747                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5748                     link_too_big = "AFTER";
5749                   break;
5750                 default:
5751                   break;
5752                 }
5753             }
5754
5755           if (do_section_details)
5756             {
5757               if (link_too_big != NULL && * link_too_big)
5758                 printf ("<%s> ", link_too_big);
5759               else
5760                 printf ("%2u ", section->sh_link);
5761               printf ("%3u %2lu\n", section->sh_info,
5762                       (unsigned long) section->sh_addralign);
5763             }
5764           else
5765             printf ("%2u %3u %2lu\n",
5766                     section->sh_link,
5767                     section->sh_info,
5768                     (unsigned long) section->sh_addralign);
5769
5770           if (link_too_big && ! * link_too_big)
5771             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5772                   i, section->sh_link);
5773         }
5774       else if (do_wide)
5775         {
5776           print_vma (section->sh_addr, LONG_HEX);
5777
5778           if ((long) section->sh_offset == section->sh_offset)
5779             printf (" %6.6lx", (unsigned long) section->sh_offset);
5780           else
5781             {
5782               putchar (' ');
5783               print_vma (section->sh_offset, LONG_HEX);
5784             }
5785
5786           if ((unsigned long) section->sh_size == section->sh_size)
5787             printf (" %6.6lx", (unsigned long) section->sh_size);
5788           else
5789             {
5790               putchar (' ');
5791               print_vma (section->sh_size, LONG_HEX);
5792             }
5793
5794           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5795             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5796           else
5797             {
5798               putchar (' ');
5799               print_vma (section->sh_entsize, LONG_HEX);
5800             }
5801
5802           if (do_section_details)
5803             fputs ("  ", stdout);
5804           else
5805             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5806
5807           printf ("%2u %3u ", section->sh_link, section->sh_info);
5808
5809           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5810             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5811           else
5812             {
5813               print_vma (section->sh_addralign, DEC);
5814               putchar ('\n');
5815             }
5816         }
5817       else if (do_section_details)
5818         {
5819           printf ("       %-15.15s  ",
5820                   get_section_type_name (section->sh_type));
5821           print_vma (section->sh_addr, LONG_HEX);
5822           if ((long) section->sh_offset == section->sh_offset)
5823             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5824           else
5825             {
5826               printf ("  ");
5827               print_vma (section->sh_offset, LONG_HEX);
5828             }
5829           printf ("  %u\n       ", section->sh_link);
5830           print_vma (section->sh_size, LONG_HEX);
5831           putchar (' ');
5832           print_vma (section->sh_entsize, LONG_HEX);
5833
5834           printf ("  %-16u  %lu\n",
5835                   section->sh_info,
5836                   (unsigned long) section->sh_addralign);
5837         }
5838       else
5839         {
5840           putchar (' ');
5841           print_vma (section->sh_addr, LONG_HEX);
5842           if ((long) section->sh_offset == section->sh_offset)
5843             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5844           else
5845             {
5846               printf ("  ");
5847               print_vma (section->sh_offset, LONG_HEX);
5848             }
5849           printf ("\n       ");
5850           print_vma (section->sh_size, LONG_HEX);
5851           printf ("  ");
5852           print_vma (section->sh_entsize, LONG_HEX);
5853
5854           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5855
5856           printf ("     %2u   %3u     %lu\n",
5857                   section->sh_link,
5858                   section->sh_info,
5859                   (unsigned long) section->sh_addralign);
5860         }
5861
5862       if (do_section_details)
5863         {
5864           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5865           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5866             {
5867               /* Minimum section size is 12 bytes for 32-bit compression
5868                  header + 12 bytes for compressed data header.  */
5869               unsigned char buf[24];
5870               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5871               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5872                             sizeof (buf), _("compression header")))
5873                 {
5874                   Elf_Internal_Chdr chdr;
5875                   get_compression_header (&chdr, buf);
5876                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5877                     printf ("       ZLIB, ");
5878                   else
5879                     printf (_("       [<unknown>: 0x%x], "),
5880                             chdr.ch_type);
5881                   print_vma (chdr.ch_size, LONG_HEX);
5882                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5883                 }
5884             }
5885         }
5886     }
5887
5888   if (!do_section_details)
5889     {
5890       if (elf_header.e_machine == EM_X86_64
5891           || elf_header.e_machine == EM_L1OM
5892           || elf_header.e_machine == EM_K1OM)
5893         printf (_("Key to Flags:\n\
5894   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5895   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5896   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5897       else
5898         printf (_("Key to Flags:\n\
5899   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5900   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5901   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5902     }
5903
5904   return 1;
5905 }
5906
5907 static const char *
5908 get_group_flags (unsigned int flags)
5909 {
5910   static char buff[32];
5911   switch (flags)
5912     {
5913     case 0:
5914       return "";
5915
5916     case GRP_COMDAT:
5917       return "COMDAT ";
5918
5919    default:
5920       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5921       break;
5922     }
5923   return buff;
5924 }
5925
5926 static int
5927 process_section_groups (FILE * file)
5928 {
5929   Elf_Internal_Shdr * section;
5930   unsigned int i;
5931   struct group * group;
5932   Elf_Internal_Shdr * symtab_sec;
5933   Elf_Internal_Shdr * strtab_sec;
5934   Elf_Internal_Sym * symtab;
5935   unsigned long num_syms;
5936   char * strtab;
5937   size_t strtab_size;
5938
5939   /* Don't process section groups unless needed.  */
5940   if (!do_unwind && !do_section_groups)
5941     return 1;
5942
5943   if (elf_header.e_shnum == 0)
5944     {
5945       if (do_section_groups)
5946         printf (_("\nThere are no sections to group in this file.\n"));
5947
5948       return 1;
5949     }
5950
5951   if (section_headers == NULL)
5952     {
5953       error (_("Section headers are not available!\n"));
5954       /* PR 13622: This can happen with a corrupt ELF header.  */
5955       return 0;
5956     }
5957
5958   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5959                                                      sizeof (struct group *));
5960
5961   if (section_headers_groups == NULL)
5962     {
5963       error (_("Out of memory reading %u section group headers\n"),
5964              elf_header.e_shnum);
5965       return 0;
5966     }
5967
5968   /* Scan the sections for the group section.  */
5969   group_count = 0;
5970   for (i = 0, section = section_headers;
5971        i < elf_header.e_shnum;
5972        i++, section++)
5973     if (section->sh_type == SHT_GROUP)
5974       group_count++;
5975
5976   if (group_count == 0)
5977     {
5978       if (do_section_groups)
5979         printf (_("\nThere are no section groups in this file.\n"));
5980
5981       return 1;
5982     }
5983
5984   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5985
5986   if (section_groups == NULL)
5987     {
5988       error (_("Out of memory reading %lu groups\n"),
5989              (unsigned long) group_count);
5990       return 0;
5991     }
5992
5993   symtab_sec = NULL;
5994   strtab_sec = NULL;
5995   symtab = NULL;
5996   num_syms = 0;
5997   strtab = NULL;
5998   strtab_size = 0;
5999   for (i = 0, section = section_headers, group = section_groups;
6000        i < elf_header.e_shnum;
6001        i++, section++)
6002     {
6003       if (section->sh_type == SHT_GROUP)
6004         {
6005           const char * name = printable_section_name (section);
6006           const char * group_name;
6007           unsigned char * start;
6008           unsigned char * indices;
6009           unsigned int entry, j, size;
6010           Elf_Internal_Shdr * sec;
6011           Elf_Internal_Sym * sym;
6012
6013           /* Get the symbol table.  */
6014           if (section->sh_link >= elf_header.e_shnum
6015               || ((sec = section_headers + section->sh_link)->sh_type
6016                   != SHT_SYMTAB))
6017             {
6018               error (_("Bad sh_link in group section `%s'\n"), name);
6019               continue;
6020             }
6021
6022           if (symtab_sec != sec)
6023             {
6024               symtab_sec = sec;
6025               if (symtab)
6026                 free (symtab);
6027               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6028             }
6029
6030           if (symtab == NULL)
6031             {
6032               error (_("Corrupt header in group section `%s'\n"), name);
6033               continue;
6034             }
6035
6036           if (section->sh_info >= num_syms)
6037             {
6038               error (_("Bad sh_info in group section `%s'\n"), name);
6039               continue;
6040             }
6041
6042           sym = symtab + section->sh_info;
6043
6044           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6045             {
6046               if (sym->st_shndx == 0
6047                   || sym->st_shndx >= elf_header.e_shnum)
6048                 {
6049                   error (_("Bad sh_info in group section `%s'\n"), name);
6050                   continue;
6051                 }
6052
6053               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6054               strtab_sec = NULL;
6055               if (strtab)
6056                 free (strtab);
6057               strtab = NULL;
6058               strtab_size = 0;
6059             }
6060           else
6061             {
6062               /* Get the string table.  */
6063               if (symtab_sec->sh_link >= elf_header.e_shnum)
6064                 {
6065                   strtab_sec = NULL;
6066                   if (strtab)
6067                     free (strtab);
6068                   strtab = NULL;
6069                   strtab_size = 0;
6070                 }
6071               else if (strtab_sec
6072                        != (sec = section_headers + symtab_sec->sh_link))
6073                 {
6074                   strtab_sec = sec;
6075                   if (strtab)
6076                     free (strtab);
6077
6078                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6079                                               1, strtab_sec->sh_size,
6080                                               _("string table"));
6081                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6082                 }
6083               group_name = sym->st_name < strtab_size
6084                 ? strtab + sym->st_name : _("<corrupt>");
6085             }
6086
6087           /* PR 17531: file: loop.  */
6088           if (section->sh_entsize > section->sh_size)
6089             {
6090               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6091                      printable_section_name (section),
6092                      (unsigned long) section->sh_entsize,
6093                      (unsigned long) section->sh_size);
6094               break;
6095             }
6096
6097           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6098                                               1, section->sh_size,
6099                                               _("section data"));
6100           if (start == NULL)
6101             continue;
6102
6103           indices = start;
6104           size = (section->sh_size / section->sh_entsize) - 1;
6105           entry = byte_get (indices, 4);
6106           indices += 4;
6107
6108           if (do_section_groups)
6109             {
6110               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6111                       get_group_flags (entry), i, name, group_name, size);
6112
6113               printf (_("   [Index]    Name\n"));
6114             }
6115
6116           group->group_index = i;
6117
6118           for (j = 0; j < size; j++)
6119             {
6120               struct group_list * g;
6121
6122               entry = byte_get (indices, 4);
6123               indices += 4;
6124
6125               if (entry >= elf_header.e_shnum)
6126                 {
6127                   static unsigned num_group_errors = 0;
6128
6129                   if (num_group_errors ++ < 10)
6130                     {
6131                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6132                              entry, i, elf_header.e_shnum - 1);
6133                       if (num_group_errors == 10)
6134                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6135                     }
6136                   continue;
6137                 }
6138
6139               if (section_headers_groups [entry] != NULL)
6140                 {
6141                   if (entry)
6142                     {
6143                       static unsigned num_errs = 0;
6144
6145                       if (num_errs ++ < 10)
6146                         {
6147                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6148                                  entry, i,
6149                                  section_headers_groups [entry]->group_index);
6150                           if (num_errs == 10)
6151                             warn (_("Further error messages about already contained group sections suppressed\n"));
6152                         }
6153                       continue;
6154                     }
6155                   else
6156                     {
6157                       /* Intel C/C++ compiler may put section 0 in a
6158                          section group. We just warn it the first time
6159                          and ignore it afterwards.  */
6160                       static int warned = 0;
6161                       if (!warned)
6162                         {
6163                           error (_("section 0 in group section [%5u]\n"),
6164                                  section_headers_groups [entry]->group_index);
6165                           warned++;
6166                         }
6167                     }
6168                 }
6169
6170               section_headers_groups [entry] = group;
6171
6172               if (do_section_groups)
6173                 {
6174                   sec = section_headers + entry;
6175                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6176                 }
6177
6178               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6179               g->section_index = entry;
6180               g->next = group->root;
6181               group->root = g;
6182             }
6183
6184           if (start)
6185             free (start);
6186
6187           group++;
6188         }
6189     }
6190
6191   if (symtab)
6192     free (symtab);
6193   if (strtab)
6194     free (strtab);
6195   return 1;
6196 }
6197
6198 /* Data used to display dynamic fixups.  */
6199
6200 struct ia64_vms_dynfixup
6201 {
6202   bfd_vma needed_ident;         /* Library ident number.  */
6203   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6204   bfd_vma fixup_needed;         /* Index of the library.  */
6205   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6206   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6207 };
6208
6209 /* Data used to display dynamic relocations.  */
6210
6211 struct ia64_vms_dynimgrela
6212 {
6213   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6214   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6215 };
6216
6217 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6218    library).  */
6219
6220 static void
6221 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6222                               const char *strtab, unsigned int strtab_sz)
6223 {
6224   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6225   long i;
6226   const char *lib_name;
6227
6228   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6229                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6230                    _("dynamic section image fixups"));
6231   if (!imfs)
6232     return;
6233
6234   if (fixup->needed < strtab_sz)
6235     lib_name = strtab + fixup->needed;
6236   else
6237     {
6238       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6239             (unsigned long) fixup->needed);
6240       lib_name = "???";
6241     }
6242   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6243           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6244   printf
6245     (_("Seg Offset           Type                             SymVec DataType\n"));
6246
6247   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6248     {
6249       unsigned int type;
6250       const char *rtype;
6251
6252       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6253       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6254       type = BYTE_GET (imfs [i].type);
6255       rtype = elf_ia64_reloc_type (type);
6256       if (rtype == NULL)
6257         printf (" 0x%08x                       ", type);
6258       else
6259         printf (" %-32s ", rtype);
6260       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6261       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6262     }
6263
6264   free (imfs);
6265 }
6266
6267 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6268
6269 static void
6270 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6271 {
6272   Elf64_External_VMS_IMAGE_RELA *imrs;
6273   long i;
6274
6275   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6276                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6277                    _("dynamic section image relocations"));
6278   if (!imrs)
6279     return;
6280
6281   printf (_("\nImage relocs\n"));
6282   printf
6283     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6284
6285   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6286     {
6287       unsigned int type;
6288       const char *rtype;
6289
6290       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6291       printf ("%08" BFD_VMA_FMT "x ",
6292               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6293       type = BYTE_GET (imrs [i].type);
6294       rtype = elf_ia64_reloc_type (type);
6295       if (rtype == NULL)
6296         printf ("0x%08x                      ", type);
6297       else
6298         printf ("%-31s ", rtype);
6299       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6300       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6301       printf ("%08" BFD_VMA_FMT "x\n",
6302               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6303     }
6304
6305   free (imrs);
6306 }
6307
6308 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6309
6310 static int
6311 process_ia64_vms_dynamic_relocs (FILE *file)
6312 {
6313   struct ia64_vms_dynfixup fixup;
6314   struct ia64_vms_dynimgrela imgrela;
6315   Elf_Internal_Dyn *entry;
6316   int res = 0;
6317   bfd_vma strtab_off = 0;
6318   bfd_vma strtab_sz = 0;
6319   char *strtab = NULL;
6320
6321   memset (&fixup, 0, sizeof (fixup));
6322   memset (&imgrela, 0, sizeof (imgrela));
6323
6324   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6325   for (entry = dynamic_section;
6326        entry < dynamic_section + dynamic_nent;
6327        entry++)
6328     {
6329       switch (entry->d_tag)
6330         {
6331         case DT_IA_64_VMS_STRTAB_OFFSET:
6332           strtab_off = entry->d_un.d_val;
6333           break;
6334         case DT_STRSZ:
6335           strtab_sz = entry->d_un.d_val;
6336           if (strtab == NULL)
6337             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6338                                1, strtab_sz, _("dynamic string section"));
6339           break;
6340
6341         case DT_IA_64_VMS_NEEDED_IDENT:
6342           fixup.needed_ident = entry->d_un.d_val;
6343           break;
6344         case DT_NEEDED:
6345           fixup.needed = entry->d_un.d_val;
6346           break;
6347         case DT_IA_64_VMS_FIXUP_NEEDED:
6348           fixup.fixup_needed = entry->d_un.d_val;
6349           break;
6350         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6351           fixup.fixup_rela_cnt = entry->d_un.d_val;
6352           break;
6353         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6354           fixup.fixup_rela_off = entry->d_un.d_val;
6355           res++;
6356           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6357           break;
6358
6359         case DT_IA_64_VMS_IMG_RELA_CNT:
6360           imgrela.img_rela_cnt = entry->d_un.d_val;
6361           break;
6362         case DT_IA_64_VMS_IMG_RELA_OFF:
6363           imgrela.img_rela_off = entry->d_un.d_val;
6364           res++;
6365           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6366           break;
6367
6368         default:
6369           break;
6370         }
6371     }
6372
6373   if (strtab != NULL)
6374     free (strtab);
6375
6376   return res;
6377 }
6378
6379 static struct
6380 {
6381   const char * name;
6382   int reloc;
6383   int size;
6384   int rela;
6385 } dynamic_relocations [] =
6386 {
6387     { "REL", DT_REL, DT_RELSZ, FALSE },
6388     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6389     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6390 };
6391
6392 /* Process the reloc section.  */
6393
6394 static int
6395 process_relocs (FILE * file)
6396 {
6397   unsigned long rel_size;
6398   unsigned long rel_offset;
6399
6400
6401   if (!do_reloc)
6402     return 1;
6403
6404   if (do_using_dynamic)
6405     {
6406       int is_rela;
6407       const char * name;
6408       int has_dynamic_reloc;
6409       unsigned int i;
6410
6411       has_dynamic_reloc = 0;
6412
6413       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6414         {
6415           is_rela = dynamic_relocations [i].rela;
6416           name = dynamic_relocations [i].name;
6417           rel_size = dynamic_info [dynamic_relocations [i].size];
6418           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6419
6420           has_dynamic_reloc |= rel_size;
6421
6422           if (is_rela == UNKNOWN)
6423             {
6424               if (dynamic_relocations [i].reloc == DT_JMPREL)
6425                 switch (dynamic_info[DT_PLTREL])
6426                   {
6427                   case DT_REL:
6428                     is_rela = FALSE;
6429                     break;
6430                   case DT_RELA:
6431                     is_rela = TRUE;
6432                     break;
6433                   }
6434             }
6435
6436           if (rel_size)
6437             {
6438               printf
6439                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6440                  name, rel_offset, rel_size);
6441
6442               dump_relocations (file,
6443                                 offset_from_vma (file, rel_offset, rel_size),
6444                                 rel_size,
6445                                 dynamic_symbols, num_dynamic_syms,
6446                                 dynamic_strings, dynamic_strings_length,
6447                                 is_rela, 1);
6448             }
6449         }
6450
6451       if (is_ia64_vms ())
6452         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6453
6454       if (! has_dynamic_reloc)
6455         printf (_("\nThere are no dynamic relocations in this file.\n"));
6456     }
6457   else
6458     {
6459       Elf_Internal_Shdr * section;
6460       unsigned long i;
6461       int found = 0;
6462
6463       for (i = 0, section = section_headers;
6464            i < elf_header.e_shnum;
6465            i++, section++)
6466         {
6467           if (   section->sh_type != SHT_RELA
6468               && section->sh_type != SHT_REL)
6469             continue;
6470
6471           rel_offset = section->sh_offset;
6472           rel_size   = section->sh_size;
6473
6474           if (rel_size)
6475             {
6476               Elf_Internal_Shdr * strsec;
6477               int is_rela;
6478
6479               printf (_("\nRelocation section "));
6480
6481               if (string_table == NULL)
6482                 printf ("%d", section->sh_name);
6483               else
6484                 printf ("'%s'", printable_section_name (section));
6485
6486               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6487                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6488
6489               is_rela = section->sh_type == SHT_RELA;
6490
6491               if (section->sh_link != 0
6492                   && section->sh_link < elf_header.e_shnum)
6493                 {
6494                   Elf_Internal_Shdr * symsec;
6495                   Elf_Internal_Sym *  symtab;
6496                   unsigned long nsyms;
6497                   unsigned long strtablen = 0;
6498                   char * strtab = NULL;
6499
6500                   symsec = section_headers + section->sh_link;
6501                   if (symsec->sh_type != SHT_SYMTAB
6502                       && symsec->sh_type != SHT_DYNSYM)
6503                     continue;
6504
6505                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6506
6507                   if (symtab == NULL)
6508                     continue;
6509
6510                   if (symsec->sh_link != 0
6511                       && symsec->sh_link < elf_header.e_shnum)
6512                     {
6513                       strsec = section_headers + symsec->sh_link;
6514
6515                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6516                                                   1, strsec->sh_size,
6517                                                   _("string table"));
6518                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6519                     }
6520
6521                   dump_relocations (file, rel_offset, rel_size,
6522                                     symtab, nsyms, strtab, strtablen,
6523                                     is_rela,
6524                                     symsec->sh_type == SHT_DYNSYM);
6525                   if (strtab)
6526                     free (strtab);
6527                   free (symtab);
6528                 }
6529               else
6530                 dump_relocations (file, rel_offset, rel_size,
6531                                   NULL, 0, NULL, 0, is_rela, 0);
6532
6533               found = 1;
6534             }
6535         }
6536
6537       if (! found)
6538         printf (_("\nThere are no relocations in this file.\n"));
6539     }
6540
6541   return 1;
6542 }
6543
6544 /* An absolute address consists of a section and an offset.  If the
6545    section is NULL, the offset itself is the address, otherwise, the
6546    address equals to LOAD_ADDRESS(section) + offset.  */
6547
6548 struct absaddr
6549 {
6550   unsigned short section;
6551   bfd_vma offset;
6552 };
6553
6554 #define ABSADDR(a) \
6555   ((a).section \
6556    ? section_headers [(a).section].sh_addr + (a).offset \
6557    : (a).offset)
6558
6559 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6560    name, if found, and the offset from the symbol to ADDR.  */
6561
6562 static void
6563 find_symbol_for_address (Elf_Internal_Sym * symtab,
6564                          unsigned long      nsyms,
6565                          const char *       strtab,
6566                          unsigned long      strtab_size,
6567                          struct absaddr     addr,
6568                          const char **      symname,
6569                          bfd_vma *          offset)
6570 {
6571   bfd_vma dist = 0x100000;
6572   Elf_Internal_Sym * sym;
6573   Elf_Internal_Sym * beg;
6574   Elf_Internal_Sym * end;
6575   Elf_Internal_Sym * best = NULL;
6576
6577   REMOVE_ARCH_BITS (addr.offset);
6578   beg = symtab;
6579   end = symtab + nsyms;
6580
6581   while (beg < end)
6582     {
6583       bfd_vma value;
6584
6585       sym = beg + (end - beg) / 2;
6586
6587       value = sym->st_value;
6588       REMOVE_ARCH_BITS (value);
6589
6590       if (sym->st_name != 0
6591           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6592           && addr.offset >= value
6593           && addr.offset - value < dist)
6594         {
6595           best = sym;
6596           dist = addr.offset - value;
6597           if (!dist)
6598             break;
6599         }
6600
6601       if (addr.offset < value)
6602         end = sym;
6603       else
6604         beg = sym + 1;
6605     }
6606
6607   if (best)
6608     {
6609       *symname = (best->st_name >= strtab_size
6610                   ? _("<corrupt>") : strtab + best->st_name);
6611       *offset = dist;
6612       return;
6613     }
6614
6615   *symname = NULL;
6616   *offset = addr.offset;
6617 }
6618
6619 static int
6620 symcmp (const void *p, const void *q)
6621 {
6622   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6623   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6624
6625   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6626 }
6627
6628 /* Process the unwind section.  */
6629
6630 #include "unwind-ia64.h"
6631
6632 struct ia64_unw_table_entry
6633 {
6634   struct absaddr start;
6635   struct absaddr end;
6636   struct absaddr info;
6637 };
6638
6639 struct ia64_unw_aux_info
6640 {
6641   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6642   unsigned long table_len;              /* Length of unwind table.  */
6643   unsigned char * info;                 /* Unwind info.  */
6644   unsigned long info_size;              /* Size of unwind info.  */
6645   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6646   bfd_vma seg_base;                     /* Starting address of segment.  */
6647   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6648   unsigned long nsyms;                  /* Number of symbols.  */
6649   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6650   unsigned long nfuns;                  /* Number of entries in funtab.  */
6651   char * strtab;                        /* The string table.  */
6652   unsigned long strtab_size;            /* Size of string table.  */
6653 };
6654
6655 static void
6656 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6657 {
6658   struct ia64_unw_table_entry * tp;
6659   unsigned long j, nfuns;
6660   int in_body;
6661
6662   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6663   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6664     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6665       aux->funtab[nfuns++] = aux->symtab[j];
6666   aux->nfuns = nfuns;
6667   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6668
6669   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6670     {
6671       bfd_vma stamp;
6672       bfd_vma offset;
6673       const unsigned char * dp;
6674       const unsigned char * head;
6675       const unsigned char * end;
6676       const char * procname;
6677
6678       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6679                                aux->strtab_size, tp->start, &procname, &offset);
6680
6681       fputs ("\n<", stdout);
6682
6683       if (procname)
6684         {
6685           fputs (procname, stdout);
6686
6687           if (offset)
6688             printf ("+%lx", (unsigned long) offset);
6689         }
6690
6691       fputs (">: [", stdout);
6692       print_vma (tp->start.offset, PREFIX_HEX);
6693       fputc ('-', stdout);
6694       print_vma (tp->end.offset, PREFIX_HEX);
6695       printf ("], info at +0x%lx\n",
6696               (unsigned long) (tp->info.offset - aux->seg_base));
6697
6698       /* PR 17531: file: 86232b32.  */
6699       if (aux->info == NULL)
6700         continue;
6701
6702       /* PR 17531: file: 0997b4d1.  */
6703       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6704         {
6705           warn (_("Invalid offset %lx in table entry %ld\n"),
6706                 (long) tp->info.offset, (long) (tp - aux->table));
6707           continue;
6708         }
6709
6710       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6711       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6712
6713       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6714               (unsigned) UNW_VER (stamp),
6715               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6716               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6717               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6718               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6719
6720       if (UNW_VER (stamp) != 1)
6721         {
6722           printf (_("\tUnknown version.\n"));
6723           continue;
6724         }
6725
6726       in_body = 0;
6727       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6728       /* PR 17531: file: 16ceda89.  */
6729       if (end > aux->info + aux->info_size)
6730         end = aux->info + aux->info_size;
6731       for (dp = head + 8; dp < end;)
6732         dp = unw_decode (dp, in_body, & in_body);
6733     }
6734
6735   free (aux->funtab);
6736 }
6737
6738 static bfd_boolean
6739 slurp_ia64_unwind_table (FILE * file,
6740                          struct ia64_unw_aux_info * aux,
6741                          Elf_Internal_Shdr * sec)
6742 {
6743   unsigned long size, nrelas, i;
6744   Elf_Internal_Phdr * seg;
6745   struct ia64_unw_table_entry * tep;
6746   Elf_Internal_Shdr * relsec;
6747   Elf_Internal_Rela * rela;
6748   Elf_Internal_Rela * rp;
6749   unsigned char * table;
6750   unsigned char * tp;
6751   Elf_Internal_Sym * sym;
6752   const char * relname;
6753
6754   aux->table_len = 0;
6755
6756   /* First, find the starting address of the segment that includes
6757      this section: */
6758
6759   if (elf_header.e_phnum)
6760     {
6761       if (! get_program_headers (file))
6762           return FALSE;
6763
6764       for (seg = program_headers;
6765            seg < program_headers + elf_header.e_phnum;
6766            ++seg)
6767         {
6768           if (seg->p_type != PT_LOAD)
6769             continue;
6770
6771           if (sec->sh_addr >= seg->p_vaddr
6772               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6773             {
6774               aux->seg_base = seg->p_vaddr;
6775               break;
6776             }
6777         }
6778     }
6779
6780   /* Second, build the unwind table from the contents of the unwind section:  */
6781   size = sec->sh_size;
6782   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6783                                       _("unwind table"));
6784   if (!table)
6785     return FALSE;
6786
6787   aux->table_len = size / (3 * eh_addr_size);
6788   aux->table = (struct ia64_unw_table_entry *)
6789     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6790   tep = aux->table;
6791
6792   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6793     {
6794       tep->start.section = SHN_UNDEF;
6795       tep->end.section   = SHN_UNDEF;
6796       tep->info.section  = SHN_UNDEF;
6797       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6798       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6799       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6800       tep->start.offset += aux->seg_base;
6801       tep->end.offset   += aux->seg_base;
6802       tep->info.offset  += aux->seg_base;
6803     }
6804   free (table);
6805
6806   /* Third, apply any relocations to the unwind table:  */
6807   for (relsec = section_headers;
6808        relsec < section_headers + elf_header.e_shnum;
6809        ++relsec)
6810     {
6811       if (relsec->sh_type != SHT_RELA
6812           || relsec->sh_info >= elf_header.e_shnum
6813           || section_headers + relsec->sh_info != sec)
6814         continue;
6815
6816       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6817                               & rela, & nrelas))
6818         {
6819           free (aux->table);
6820           aux->table = NULL;
6821           aux->table_len = 0;
6822           return FALSE;
6823         }
6824
6825       for (rp = rela; rp < rela + nrelas; ++rp)
6826         {
6827           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6828           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6829
6830           /* PR 17531: file: 9fa67536.  */
6831           if (relname == NULL)
6832             {
6833               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6834               continue;
6835             }
6836
6837           if (! const_strneq (relname, "R_IA64_SEGREL"))
6838             {
6839               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6840               continue;
6841             }
6842
6843           i = rp->r_offset / (3 * eh_addr_size);
6844
6845           /* PR 17531: file: 5bc8d9bf.  */
6846           if (i >= aux->table_len)
6847             {
6848               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6849               continue;
6850             }
6851
6852           switch (rp->r_offset / eh_addr_size % 3)
6853             {
6854             case 0:
6855               aux->table[i].start.section = sym->st_shndx;
6856               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6857               break;
6858             case 1:
6859               aux->table[i].end.section   = sym->st_shndx;
6860               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6861               break;
6862             case 2:
6863               aux->table[i].info.section  = sym->st_shndx;
6864               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6865               break;
6866             default:
6867               break;
6868             }
6869         }
6870
6871       free (rela);
6872     }
6873
6874   return TRUE;
6875 }
6876
6877 static void
6878 ia64_process_unwind (FILE * file)
6879 {
6880   Elf_Internal_Shdr * sec;
6881   Elf_Internal_Shdr * unwsec = NULL;
6882   Elf_Internal_Shdr * strsec;
6883   unsigned long i, unwcount = 0, unwstart = 0;
6884   struct ia64_unw_aux_info aux;
6885
6886   memset (& aux, 0, sizeof (aux));
6887
6888   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6889     {
6890       if (sec->sh_type == SHT_SYMTAB
6891           && sec->sh_link < elf_header.e_shnum)
6892         {
6893           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6894
6895           strsec = section_headers + sec->sh_link;
6896           if (aux.strtab != NULL)
6897             {
6898               error (_("Multiple auxillary string tables encountered\n"));
6899               free (aux.strtab);
6900             }
6901           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6902                                           1, strsec->sh_size,
6903                                           _("string table"));
6904           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6905         }
6906       else if (sec->sh_type == SHT_IA_64_UNWIND)
6907         unwcount++;
6908     }
6909
6910   if (!unwcount)
6911     printf (_("\nThere are no unwind sections in this file.\n"));
6912
6913   while (unwcount-- > 0)
6914     {
6915       char * suffix;
6916       size_t len, len2;
6917
6918       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6919            i < elf_header.e_shnum; ++i, ++sec)
6920         if (sec->sh_type == SHT_IA_64_UNWIND)
6921           {
6922             unwsec = sec;
6923             break;
6924           }
6925       /* We have already counted the number of SHT_IA64_UNWIND
6926          sections so the loop above should never fail.  */
6927       assert (unwsec != NULL);
6928
6929       unwstart = i + 1;
6930       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6931
6932       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6933         {
6934           /* We need to find which section group it is in.  */
6935           struct group_list * g;
6936
6937           if (section_headers_groups == NULL
6938               || section_headers_groups [i] == NULL)
6939             i = elf_header.e_shnum;
6940           else
6941             {
6942               g = section_headers_groups [i]->root;
6943
6944               for (; g != NULL; g = g->next)
6945                 {
6946                   sec = section_headers + g->section_index;
6947
6948                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6949                     break;
6950                 }
6951
6952               if (g == NULL)
6953                 i = elf_header.e_shnum;
6954             }
6955         }
6956       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6957         {
6958           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6959           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6960           suffix = SECTION_NAME (unwsec) + len;
6961           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6962                ++i, ++sec)
6963             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6964                 && streq (SECTION_NAME (sec) + len2, suffix))
6965               break;
6966         }
6967       else
6968         {
6969           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6970              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6971           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6972           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6973           suffix = "";
6974           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6975             suffix = SECTION_NAME (unwsec) + len;
6976           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6977                ++i, ++sec)
6978             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6979                 && streq (SECTION_NAME (sec) + len2, suffix))
6980               break;
6981         }
6982
6983       if (i == elf_header.e_shnum)
6984         {
6985           printf (_("\nCould not find unwind info section for "));
6986
6987           if (string_table == NULL)
6988             printf ("%d", unwsec->sh_name);
6989           else
6990             printf ("'%s'", printable_section_name (unwsec));
6991         }
6992       else
6993         {
6994           aux.info_addr = sec->sh_addr;
6995           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6996                                                  sec->sh_size,
6997                                                  _("unwind info"));
6998           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6999
7000           printf (_("\nUnwind section "));
7001
7002           if (string_table == NULL)
7003             printf ("%d", unwsec->sh_name);
7004           else
7005             printf ("'%s'", printable_section_name (unwsec));
7006
7007           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7008                   (unsigned long) unwsec->sh_offset,
7009                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7010
7011           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7012               && aux.table_len > 0)
7013             dump_ia64_unwind (& aux);
7014
7015           if (aux.table)
7016             free ((char *) aux.table);
7017           if (aux.info)
7018             free ((char *) aux.info);
7019           aux.table = NULL;
7020           aux.info = NULL;
7021         }
7022     }
7023
7024   if (aux.symtab)
7025     free (aux.symtab);
7026   if (aux.strtab)
7027     free ((char *) aux.strtab);
7028 }
7029
7030 struct hppa_unw_table_entry
7031   {
7032     struct absaddr start;
7033     struct absaddr end;
7034     unsigned int Cannot_unwind:1;               /* 0 */
7035     unsigned int Millicode:1;                   /* 1 */
7036     unsigned int Millicode_save_sr0:1;          /* 2 */
7037     unsigned int Region_description:2;          /* 3..4 */
7038     unsigned int reserved1:1;                   /* 5 */
7039     unsigned int Entry_SR:1;                    /* 6 */
7040     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7041     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7042     unsigned int Args_stored:1;                 /* 16 */
7043     unsigned int Variable_Frame:1;              /* 17 */
7044     unsigned int Separate_Package_Body:1;       /* 18 */
7045     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7046     unsigned int Stack_Overflow_Check:1;        /* 20 */
7047     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7048     unsigned int Ada_Region:1;                  /* 22 */
7049     unsigned int cxx_info:1;                    /* 23 */
7050     unsigned int cxx_try_catch:1;               /* 24 */
7051     unsigned int sched_entry_seq:1;             /* 25 */
7052     unsigned int reserved2:1;                   /* 26 */
7053     unsigned int Save_SP:1;                     /* 27 */
7054     unsigned int Save_RP:1;                     /* 28 */
7055     unsigned int Save_MRP_in_frame:1;           /* 29 */
7056     unsigned int extn_ptr_defined:1;            /* 30 */
7057     unsigned int Cleanup_defined:1;             /* 31 */
7058
7059     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7060     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7061     unsigned int Large_frame:1;                 /* 2 */
7062     unsigned int Pseudo_SP_Set:1;               /* 3 */
7063     unsigned int reserved4:1;                   /* 4 */
7064     unsigned int Total_frame_size:27;           /* 5..31 */
7065   };
7066
7067 struct hppa_unw_aux_info
7068 {
7069   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7070   unsigned long table_len;              /* Length of unwind table.  */
7071   bfd_vma seg_base;                     /* Starting address of segment.  */
7072   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7073   unsigned long nsyms;                  /* Number of symbols.  */
7074   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7075   unsigned long nfuns;                  /* Number of entries in funtab.  */
7076   char * strtab;                        /* The string table.  */
7077   unsigned long strtab_size;            /* Size of string table.  */
7078 };
7079
7080 static void
7081 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7082 {
7083   struct hppa_unw_table_entry * tp;
7084   unsigned long j, nfuns;
7085
7086   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7087   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7088     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7089       aux->funtab[nfuns++] = aux->symtab[j];
7090   aux->nfuns = nfuns;
7091   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7092
7093   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7094     {
7095       bfd_vma offset;
7096       const char * procname;
7097
7098       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7099                                aux->strtab_size, tp->start, &procname,
7100                                &offset);
7101
7102       fputs ("\n<", stdout);
7103
7104       if (procname)
7105         {
7106           fputs (procname, stdout);
7107
7108           if (offset)
7109             printf ("+%lx", (unsigned long) offset);
7110         }
7111
7112       fputs (">: [", stdout);
7113       print_vma (tp->start.offset, PREFIX_HEX);
7114       fputc ('-', stdout);
7115       print_vma (tp->end.offset, PREFIX_HEX);
7116       printf ("]\n\t");
7117
7118 #define PF(_m) if (tp->_m) printf (#_m " ");
7119 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7120       PF(Cannot_unwind);
7121       PF(Millicode);
7122       PF(Millicode_save_sr0);
7123       /* PV(Region_description);  */
7124       PF(Entry_SR);
7125       PV(Entry_FR);
7126       PV(Entry_GR);
7127       PF(Args_stored);
7128       PF(Variable_Frame);
7129       PF(Separate_Package_Body);
7130       PF(Frame_Extension_Millicode);
7131       PF(Stack_Overflow_Check);
7132       PF(Two_Instruction_SP_Increment);
7133       PF(Ada_Region);
7134       PF(cxx_info);
7135       PF(cxx_try_catch);
7136       PF(sched_entry_seq);
7137       PF(Save_SP);
7138       PF(Save_RP);
7139       PF(Save_MRP_in_frame);
7140       PF(extn_ptr_defined);
7141       PF(Cleanup_defined);
7142       PF(MPE_XL_interrupt_marker);
7143       PF(HP_UX_interrupt_marker);
7144       PF(Large_frame);
7145       PF(Pseudo_SP_Set);
7146       PV(Total_frame_size);
7147 #undef PF
7148 #undef PV
7149     }
7150
7151   printf ("\n");
7152
7153   free (aux->funtab);
7154 }
7155
7156 static int
7157 slurp_hppa_unwind_table (FILE * file,
7158                          struct hppa_unw_aux_info * aux,
7159                          Elf_Internal_Shdr * sec)
7160 {
7161   unsigned long size, unw_ent_size, nentries, nrelas, i;
7162   Elf_Internal_Phdr * seg;
7163   struct hppa_unw_table_entry * tep;
7164   Elf_Internal_Shdr * relsec;
7165   Elf_Internal_Rela * rela;
7166   Elf_Internal_Rela * rp;
7167   unsigned char * table;
7168   unsigned char * tp;
7169   Elf_Internal_Sym * sym;
7170   const char * relname;
7171
7172   /* First, find the starting address of the segment that includes
7173      this section.  */
7174
7175   if (elf_header.e_phnum)
7176     {
7177       if (! get_program_headers (file))
7178         return 0;
7179
7180       for (seg = program_headers;
7181            seg < program_headers + elf_header.e_phnum;
7182            ++seg)
7183         {
7184           if (seg->p_type != PT_LOAD)
7185             continue;
7186
7187           if (sec->sh_addr >= seg->p_vaddr
7188               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7189             {
7190               aux->seg_base = seg->p_vaddr;
7191               break;
7192             }
7193         }
7194     }
7195
7196   /* Second, build the unwind table from the contents of the unwind
7197      section.  */
7198   size = sec->sh_size;
7199   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7200                                       _("unwind table"));
7201   if (!table)
7202     return 0;
7203
7204   unw_ent_size = 16;
7205   nentries = size / unw_ent_size;
7206   size = unw_ent_size * nentries;
7207
7208   tep = aux->table = (struct hppa_unw_table_entry *)
7209       xcmalloc (nentries, sizeof (aux->table[0]));
7210
7211   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7212     {
7213       unsigned int tmp1, tmp2;
7214
7215       tep->start.section = SHN_UNDEF;
7216       tep->end.section   = SHN_UNDEF;
7217
7218       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7219       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7220       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7221       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7222
7223       tep->start.offset += aux->seg_base;
7224       tep->end.offset   += aux->seg_base;
7225
7226       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7227       tep->Millicode = (tmp1 >> 30) & 0x1;
7228       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7229       tep->Region_description = (tmp1 >> 27) & 0x3;
7230       tep->reserved1 = (tmp1 >> 26) & 0x1;
7231       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7232       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7233       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7234       tep->Args_stored = (tmp1 >> 15) & 0x1;
7235       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7236       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7237       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7238       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7239       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7240       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7241       tep->cxx_info = (tmp1 >> 8) & 0x1;
7242       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7243       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7244       tep->reserved2 = (tmp1 >> 5) & 0x1;
7245       tep->Save_SP = (tmp1 >> 4) & 0x1;
7246       tep->Save_RP = (tmp1 >> 3) & 0x1;
7247       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7248       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7249       tep->Cleanup_defined = tmp1 & 0x1;
7250
7251       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7252       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7253       tep->Large_frame = (tmp2 >> 29) & 0x1;
7254       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7255       tep->reserved4 = (tmp2 >> 27) & 0x1;
7256       tep->Total_frame_size = tmp2 & 0x7ffffff;
7257     }
7258   free (table);
7259
7260   /* Third, apply any relocations to the unwind table.  */
7261   for (relsec = section_headers;
7262        relsec < section_headers + elf_header.e_shnum;
7263        ++relsec)
7264     {
7265       if (relsec->sh_type != SHT_RELA
7266           || relsec->sh_info >= elf_header.e_shnum
7267           || section_headers + relsec->sh_info != sec)
7268         continue;
7269
7270       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7271                               & rela, & nrelas))
7272         return 0;
7273
7274       for (rp = rela; rp < rela + nrelas; ++rp)
7275         {
7276           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7277           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7278
7279           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7280           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7281             {
7282               warn (_("Skipping unexpected relocation type %s\n"), relname);
7283               continue;
7284             }
7285
7286           i = rp->r_offset / unw_ent_size;
7287
7288           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7289             {
7290             case 0:
7291               aux->table[i].start.section = sym->st_shndx;
7292               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7293               break;
7294             case 1:
7295               aux->table[i].end.section   = sym->st_shndx;
7296               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7297               break;
7298             default:
7299               break;
7300             }
7301         }
7302
7303       free (rela);
7304     }
7305
7306   aux->table_len = nentries;
7307
7308   return 1;
7309 }
7310
7311 static void
7312 hppa_process_unwind (FILE * file)
7313 {
7314   struct hppa_unw_aux_info aux;
7315   Elf_Internal_Shdr * unwsec = NULL;
7316   Elf_Internal_Shdr * strsec;
7317   Elf_Internal_Shdr * sec;
7318   unsigned long i;
7319
7320   if (string_table == NULL)
7321     return;
7322
7323   memset (& aux, 0, sizeof (aux));
7324
7325   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7326     {
7327       if (sec->sh_type == SHT_SYMTAB
7328           && sec->sh_link < elf_header.e_shnum)
7329         {
7330           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7331
7332           strsec = section_headers + sec->sh_link;
7333           if (aux.strtab != NULL)
7334             {
7335               error (_("Multiple auxillary string tables encountered\n"));
7336               free (aux.strtab);
7337             }
7338           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7339                                           1, strsec->sh_size,
7340                                           _("string table"));
7341           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7342         }
7343       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7344         unwsec = sec;
7345     }
7346
7347   if (!unwsec)
7348     printf (_("\nThere are no unwind sections in this file.\n"));
7349
7350   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7351     {
7352       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7353         {
7354           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7355                   printable_section_name (sec),
7356                   (unsigned long) sec->sh_offset,
7357                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7358
7359           slurp_hppa_unwind_table (file, &aux, sec);
7360           if (aux.table_len > 0)
7361             dump_hppa_unwind (&aux);
7362
7363           if (aux.table)
7364             free ((char *) aux.table);
7365           aux.table = NULL;
7366         }
7367     }
7368
7369   if (aux.symtab)
7370     free (aux.symtab);
7371   if (aux.strtab)
7372     free ((char *) aux.strtab);
7373 }
7374
7375 struct arm_section
7376 {
7377   unsigned char *      data;            /* The unwind data.  */
7378   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7379   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7380   unsigned long        nrelas;          /* The number of relocations.  */
7381   unsigned int         rel_type;        /* REL or RELA ?  */
7382   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7383 };
7384
7385 struct arm_unw_aux_info
7386 {
7387   FILE *              file;             /* The file containing the unwind sections.  */
7388   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7389   unsigned long       nsyms;            /* Number of symbols.  */
7390   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7391   unsigned long       nfuns;            /* Number of these symbols.  */
7392   char *              strtab;           /* The file's string table.  */
7393   unsigned long       strtab_size;      /* Size of string table.  */
7394 };
7395
7396 static const char *
7397 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7398                         bfd_vma fn, struct absaddr addr)
7399 {
7400   const char *procname;
7401   bfd_vma sym_offset;
7402
7403   if (addr.section == SHN_UNDEF)
7404     addr.offset = fn;
7405
7406   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7407                            aux->strtab_size, addr, &procname,
7408                            &sym_offset);
7409
7410   print_vma (fn, PREFIX_HEX);
7411
7412   if (procname)
7413     {
7414       fputs (" <", stdout);
7415       fputs (procname, stdout);
7416
7417       if (sym_offset)
7418         printf ("+0x%lx", (unsigned long) sym_offset);
7419       fputc ('>', stdout);
7420     }
7421
7422   return procname;
7423 }
7424
7425 static void
7426 arm_free_section (struct arm_section *arm_sec)
7427 {
7428   if (arm_sec->data != NULL)
7429     free (arm_sec->data);
7430
7431   if (arm_sec->rela != NULL)
7432     free (arm_sec->rela);
7433 }
7434
7435 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7436       cached section and install SEC instead.
7437    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7438       and return its valued in * WORDP, relocating if necessary.
7439    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7440       relocation's offset in ADDR.
7441    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7442       into the string table of the symbol associated with the reloc.  If no
7443       reloc was applied store -1 there.
7444    5) Return TRUE upon success, FALSE otherwise.  */
7445
7446 static bfd_boolean
7447 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7448                          struct arm_section *       arm_sec,
7449                          Elf_Internal_Shdr *        sec,
7450                          bfd_vma                    word_offset,
7451                          unsigned int *             wordp,
7452                          struct absaddr *           addr,
7453                          bfd_vma *                  sym_name)
7454 {
7455   Elf_Internal_Rela *rp;
7456   Elf_Internal_Sym *sym;
7457   const char * relname;
7458   unsigned int word;
7459   bfd_boolean wrapped;
7460
7461   if (sec == NULL || arm_sec == NULL)
7462     return FALSE;
7463
7464   addr->section = SHN_UNDEF;
7465   addr->offset = 0;
7466
7467   if (sym_name != NULL)
7468     *sym_name = (bfd_vma) -1;
7469
7470   /* If necessary, update the section cache.  */
7471   if (sec != arm_sec->sec)
7472     {
7473       Elf_Internal_Shdr *relsec;
7474
7475       arm_free_section (arm_sec);
7476
7477       arm_sec->sec = sec;
7478       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7479                                 sec->sh_size, _("unwind data"));
7480       arm_sec->rela = NULL;
7481       arm_sec->nrelas = 0;
7482
7483       for (relsec = section_headers;
7484            relsec < section_headers + elf_header.e_shnum;
7485            ++relsec)
7486         {
7487           if (relsec->sh_info >= elf_header.e_shnum
7488               || section_headers + relsec->sh_info != sec
7489               /* PR 15745: Check the section type as well.  */
7490               || (relsec->sh_type != SHT_REL
7491                   && relsec->sh_type != SHT_RELA))
7492             continue;
7493
7494           arm_sec->rel_type = relsec->sh_type;
7495           if (relsec->sh_type == SHT_REL)
7496             {
7497               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7498                                      relsec->sh_size,
7499                                      & arm_sec->rela, & arm_sec->nrelas))
7500                 return FALSE;
7501             }
7502           else /* relsec->sh_type == SHT_RELA */
7503             {
7504               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7505                                       relsec->sh_size,
7506                                       & arm_sec->rela, & arm_sec->nrelas))
7507                 return FALSE;
7508             }
7509           break;
7510         }
7511
7512       arm_sec->next_rela = arm_sec->rela;
7513     }
7514
7515   /* If there is no unwind data we can do nothing.  */
7516   if (arm_sec->data == NULL)
7517     return FALSE;
7518
7519   /* If the offset is invalid then fail.  */
7520   if (word_offset > sec->sh_size - 4)
7521     return FALSE;
7522
7523   /* Get the word at the required offset.  */
7524   word = byte_get (arm_sec->data + word_offset, 4);
7525
7526   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7527   if (arm_sec->rela == NULL)
7528     {
7529       * wordp = word;
7530       return TRUE;
7531     }
7532
7533   /* Look through the relocs to find the one that applies to the provided offset.  */
7534   wrapped = FALSE;
7535   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7536     {
7537       bfd_vma prelval, offset;
7538
7539       if (rp->r_offset > word_offset && !wrapped)
7540         {
7541           rp = arm_sec->rela;
7542           wrapped = TRUE;
7543         }
7544       if (rp->r_offset > word_offset)
7545         break;
7546
7547       if (rp->r_offset & 3)
7548         {
7549           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7550                 (unsigned long) rp->r_offset);
7551           continue;
7552         }
7553
7554       if (rp->r_offset < word_offset)
7555         continue;
7556
7557       /* PR 17531: file: 027-161405-0.004  */
7558       if (aux->symtab == NULL)
7559         continue;
7560
7561       if (arm_sec->rel_type == SHT_REL)
7562         {
7563           offset = word & 0x7fffffff;
7564           if (offset & 0x40000000)
7565             offset |= ~ (bfd_vma) 0x7fffffff;
7566         }
7567       else if (arm_sec->rel_type == SHT_RELA)
7568         offset = rp->r_addend;
7569       else
7570         {
7571           error (_("Unknown section relocation type %d encountered\n"),
7572                  arm_sec->rel_type);
7573           break;
7574         }
7575
7576       /* PR 17531 file: 027-1241568-0.004.  */
7577       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7578         {
7579           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7580                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7581           break;
7582         }
7583
7584       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7585       offset += sym->st_value;
7586       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7587
7588       /* Check that we are processing the expected reloc type.  */
7589       if (elf_header.e_machine == EM_ARM)
7590         {
7591           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7592           if (relname == NULL)
7593             {
7594               warn (_("Skipping unknown ARM relocation type: %d\n"),
7595                     (int) ELF32_R_TYPE (rp->r_info));
7596               continue;
7597             }
7598
7599           if (streq (relname, "R_ARM_NONE"))
7600               continue;
7601
7602           if (! streq (relname, "R_ARM_PREL31"))
7603             {
7604               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7605               continue;
7606             }
7607         }
7608       else if (elf_header.e_machine == EM_TI_C6000)
7609         {
7610           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7611           if (relname == NULL)
7612             {
7613               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7614                     (int) ELF32_R_TYPE (rp->r_info));
7615               continue;
7616             }
7617
7618           if (streq (relname, "R_C6000_NONE"))
7619             continue;
7620
7621           if (! streq (relname, "R_C6000_PREL31"))
7622             {
7623               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7624               continue;
7625             }
7626
7627           prelval >>= 1;
7628         }
7629       else
7630         {
7631           /* This function currently only supports ARM and TI unwinders.  */
7632           warn (_("Only TI and ARM unwinders are currently supported\n"));
7633           break;
7634         }
7635
7636       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7637       addr->section = sym->st_shndx;
7638       addr->offset = offset;
7639
7640       if (sym_name)
7641         * sym_name = sym->st_name;
7642       break;
7643     }
7644
7645   *wordp = word;
7646   arm_sec->next_rela = rp;
7647
7648   return TRUE;
7649 }
7650
7651 static const char *tic6x_unwind_regnames[16] =
7652 {
7653   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7654   "A14", "A13", "A12", "A11", "A10",
7655   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7656 };
7657
7658 static void
7659 decode_tic6x_unwind_regmask (unsigned int mask)
7660 {
7661   int i;
7662
7663   for (i = 12; mask; mask >>= 1, i--)
7664     {
7665       if (mask & 1)
7666         {
7667           fputs (tic6x_unwind_regnames[i], stdout);
7668           if (mask > 1)
7669             fputs (", ", stdout);
7670         }
7671     }
7672 }
7673
7674 #define ADVANCE                                                 \
7675   if (remaining == 0 && more_words)                             \
7676     {                                                           \
7677       data_offset += 4;                                         \
7678       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7679                                      data_offset, & word, & addr, NULL))        \
7680         return;                                                 \
7681       remaining = 4;                                            \
7682       more_words--;                                             \
7683     }                                                           \
7684
7685 #define GET_OP(OP)                      \
7686   ADVANCE;                              \
7687   if (remaining)                        \
7688     {                                   \
7689       remaining--;                      \
7690       (OP) = word >> 24;                \
7691       word <<= 8;                       \
7692     }                                   \
7693   else                                  \
7694     {                                   \
7695       printf (_("[Truncated opcode]\n"));       \
7696       return;                           \
7697     }                                   \
7698   printf ("0x%02x ", OP)
7699
7700 static void
7701 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7702                             unsigned int               word,
7703                             unsigned int               remaining,
7704                             unsigned int               more_words,
7705                             bfd_vma                    data_offset,
7706                             Elf_Internal_Shdr *        data_sec,
7707                             struct arm_section *       data_arm_sec)
7708 {
7709   struct absaddr addr;
7710
7711   /* Decode the unwinding instructions.  */
7712   while (1)
7713     {
7714       unsigned int op, op2;
7715
7716       ADVANCE;
7717       if (remaining == 0)
7718         break;
7719       remaining--;
7720       op = word >> 24;
7721       word <<= 8;
7722
7723       printf ("  0x%02x ", op);
7724
7725       if ((op & 0xc0) == 0x00)
7726         {
7727           int offset = ((op & 0x3f) << 2) + 4;
7728
7729           printf ("     vsp = vsp + %d", offset);
7730         }
7731       else if ((op & 0xc0) == 0x40)
7732         {
7733           int offset = ((op & 0x3f) << 2) + 4;
7734
7735           printf ("     vsp = vsp - %d", offset);
7736         }
7737       else if ((op & 0xf0) == 0x80)
7738         {
7739           GET_OP (op2);
7740           if (op == 0x80 && op2 == 0)
7741             printf (_("Refuse to unwind"));
7742           else
7743             {
7744               unsigned int mask = ((op & 0x0f) << 8) | op2;
7745               int first = 1;
7746               int i;
7747
7748               printf ("pop {");
7749               for (i = 0; i < 12; i++)
7750                 if (mask & (1 << i))
7751                   {
7752                     if (first)
7753                       first = 0;
7754                     else
7755                       printf (", ");
7756                     printf ("r%d", 4 + i);
7757                   }
7758               printf ("}");
7759             }
7760         }
7761       else if ((op & 0xf0) == 0x90)
7762         {
7763           if (op == 0x9d || op == 0x9f)
7764             printf (_("     [Reserved]"));
7765           else
7766             printf ("     vsp = r%d", op & 0x0f);
7767         }
7768       else if ((op & 0xf0) == 0xa0)
7769         {
7770           int end = 4 + (op & 0x07);
7771           int first = 1;
7772           int i;
7773
7774           printf ("     pop {");
7775           for (i = 4; i <= end; i++)
7776             {
7777               if (first)
7778                 first = 0;
7779               else
7780                 printf (", ");
7781               printf ("r%d", i);
7782             }
7783           if (op & 0x08)
7784             {
7785               if (!first)
7786                 printf (", ");
7787               printf ("r14");
7788             }
7789           printf ("}");
7790         }
7791       else if (op == 0xb0)
7792         printf (_("     finish"));
7793       else if (op == 0xb1)
7794         {
7795           GET_OP (op2);
7796           if (op2 == 0 || (op2 & 0xf0) != 0)
7797             printf (_("[Spare]"));
7798           else
7799             {
7800               unsigned int mask = op2 & 0x0f;
7801               int first = 1;
7802               int i;
7803
7804               printf ("pop {");
7805               for (i = 0; i < 12; i++)
7806                 if (mask & (1 << i))
7807                   {
7808                     if (first)
7809                       first = 0;
7810                     else
7811                       printf (", ");
7812                     printf ("r%d", i);
7813                   }
7814               printf ("}");
7815             }
7816         }
7817       else if (op == 0xb2)
7818         {
7819           unsigned char buf[9];
7820           unsigned int i, len;
7821           unsigned long offset;
7822
7823           for (i = 0; i < sizeof (buf); i++)
7824             {
7825               GET_OP (buf[i]);
7826               if ((buf[i] & 0x80) == 0)
7827                 break;
7828             }
7829           if (i == sizeof (buf))
7830             printf (_("corrupt change to vsp"));
7831           else
7832             {
7833               offset = read_uleb128 (buf, &len, buf + i + 1);
7834               assert (len == i + 1);
7835               offset = offset * 4 + 0x204;
7836               printf ("vsp = vsp + %ld", offset);
7837             }
7838         }
7839       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7840         {
7841           unsigned int first, last;
7842
7843           GET_OP (op2);
7844           first = op2 >> 4;
7845           last = op2 & 0x0f;
7846           if (op == 0xc8)
7847             first = first + 16;
7848           printf ("pop {D%d", first);
7849           if (last)
7850             printf ("-D%d", first + last);
7851           printf ("}");
7852         }
7853       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7854         {
7855           unsigned int count = op & 0x07;
7856
7857           printf ("pop {D8");
7858           if (count)
7859             printf ("-D%d", 8 + count);
7860           printf ("}");
7861         }
7862       else if (op >= 0xc0 && op <= 0xc5)
7863         {
7864           unsigned int count = op & 0x07;
7865
7866           printf ("     pop {wR10");
7867           if (count)
7868             printf ("-wR%d", 10 + count);
7869           printf ("}");
7870         }
7871       else if (op == 0xc6)
7872         {
7873           unsigned int first, last;
7874
7875           GET_OP (op2);
7876           first = op2 >> 4;
7877           last = op2 & 0x0f;
7878           printf ("pop {wR%d", first);
7879           if (last)
7880             printf ("-wR%d", first + last);
7881           printf ("}");
7882         }
7883       else if (op == 0xc7)
7884         {
7885           GET_OP (op2);
7886           if (op2 == 0 || (op2 & 0xf0) != 0)
7887             printf (_("[Spare]"));
7888           else
7889             {
7890               unsigned int mask = op2 & 0x0f;
7891               int first = 1;
7892               int i;
7893
7894               printf ("pop {");
7895               for (i = 0; i < 4; i++)
7896                 if (mask & (1 << i))
7897                   {
7898                     if (first)
7899                       first = 0;
7900                     else
7901                       printf (", ");
7902                     printf ("wCGR%d", i);
7903                   }
7904               printf ("}");
7905             }
7906         }
7907       else
7908         printf (_("     [unsupported opcode]"));
7909       printf ("\n");
7910     }
7911 }
7912
7913 static void
7914 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
7915                               unsigned int               word,
7916                               unsigned int               remaining,
7917                               unsigned int               more_words,
7918                               bfd_vma                    data_offset,
7919                               Elf_Internal_Shdr *        data_sec,
7920                               struct arm_section *       data_arm_sec)
7921 {
7922   struct absaddr addr;
7923
7924   /* Decode the unwinding instructions.  */
7925   while (1)
7926     {
7927       unsigned int op, op2;
7928
7929       ADVANCE;
7930       if (remaining == 0)
7931         break;
7932       remaining--;
7933       op = word >> 24;
7934       word <<= 8;
7935
7936       printf ("  0x%02x ", op);
7937
7938       if ((op & 0xc0) == 0x00)
7939         {
7940           int offset = ((op & 0x3f) << 3) + 8;
7941           printf ("     sp = sp + %d", offset);
7942         }
7943       else if ((op & 0xc0) == 0x80)
7944         {
7945           GET_OP (op2);
7946           if (op == 0x80 && op2 == 0)
7947             printf (_("Refuse to unwind"));
7948           else
7949             {
7950               unsigned int mask = ((op & 0x1f) << 8) | op2;
7951               if (op & 0x20)
7952                 printf ("pop compact {");
7953               else
7954                 printf ("pop {");
7955
7956               decode_tic6x_unwind_regmask (mask);
7957               printf("}");
7958             }
7959         }
7960       else if ((op & 0xf0) == 0xc0)
7961         {
7962           unsigned int reg;
7963           unsigned int nregs;
7964           unsigned int i;
7965           const char *name;
7966           struct
7967           {
7968               unsigned int offset;
7969               unsigned int reg;
7970           } regpos[16];
7971
7972           /* Scan entire instruction first so that GET_OP output is not
7973              interleaved with disassembly.  */
7974           nregs = 0;
7975           for (i = 0; nregs < (op & 0xf); i++)
7976             {
7977               GET_OP (op2);
7978               reg = op2 >> 4;
7979               if (reg != 0xf)
7980                 {
7981                   regpos[nregs].offset = i * 2;
7982                   regpos[nregs].reg = reg;
7983                   nregs++;
7984                 }
7985
7986               reg = op2 & 0xf;
7987               if (reg != 0xf)
7988                 {
7989                   regpos[nregs].offset = i * 2 + 1;
7990                   regpos[nregs].reg = reg;
7991                   nregs++;
7992                 }
7993             }
7994
7995           printf (_("pop frame {"));
7996           reg = nregs - 1;
7997           for (i = i * 2; i > 0; i--)
7998             {
7999               if (regpos[reg].offset == i - 1)
8000                 {
8001                   name = tic6x_unwind_regnames[regpos[reg].reg];
8002                   if (reg > 0)
8003                     reg--;
8004                 }
8005               else
8006                 name = _("[pad]");
8007
8008               fputs (name, stdout);
8009               if (i > 1)
8010                 printf (", ");
8011             }
8012
8013           printf ("}");
8014         }
8015       else if (op == 0xd0)
8016         printf ("     MOV FP, SP");
8017       else if (op == 0xd1)
8018         printf ("     __c6xabi_pop_rts");
8019       else if (op == 0xd2)
8020         {
8021           unsigned char buf[9];
8022           unsigned int i, len;
8023           unsigned long offset;
8024
8025           for (i = 0; i < sizeof (buf); i++)
8026             {
8027               GET_OP (buf[i]);
8028               if ((buf[i] & 0x80) == 0)
8029                 break;
8030             }
8031           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8032           if (i == sizeof (buf))
8033             {
8034               printf ("<corrupt sp adjust>\n");
8035               warn (_("Corrupt stack pointer adjustment detected\n"));
8036               return;
8037             }
8038
8039           offset = read_uleb128 (buf, &len, buf + i + 1);
8040           assert (len == i + 1);
8041           offset = offset * 8 + 0x408;
8042           printf (_("sp = sp + %ld"), offset);
8043         }
8044       else if ((op & 0xf0) == 0xe0)
8045         {
8046           if ((op & 0x0f) == 7)
8047             printf ("     RETURN");
8048           else
8049             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8050         }
8051       else
8052         {
8053           printf (_("     [unsupported opcode]"));
8054         }
8055       putchar ('\n');
8056     }
8057 }
8058
8059 static bfd_vma
8060 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8061 {
8062   bfd_vma offset;
8063
8064   offset = word & 0x7fffffff;
8065   if (offset & 0x40000000)
8066     offset |= ~ (bfd_vma) 0x7fffffff;
8067
8068   if (elf_header.e_machine == EM_TI_C6000)
8069     offset <<= 1;
8070
8071   return offset + where;
8072 }
8073
8074 static void
8075 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8076                    unsigned int               word,
8077                    unsigned int               remaining,
8078                    bfd_vma                    data_offset,
8079                    Elf_Internal_Shdr *        data_sec,
8080                    struct arm_section *       data_arm_sec)
8081 {
8082   int per_index;
8083   unsigned int more_words = 0;
8084   struct absaddr addr;
8085   bfd_vma sym_name = (bfd_vma) -1;
8086
8087   if (remaining == 0)
8088     {
8089       /* Fetch the first word.
8090          Note - when decoding an object file the address extracted
8091          here will always be 0.  So we also pass in the sym_name
8092          parameter so that we can find the symbol associated with
8093          the personality routine.  */
8094       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8095                                      & word, & addr, & sym_name))
8096         return;
8097
8098       remaining = 4;
8099     }
8100
8101   if ((word & 0x80000000) == 0)
8102     {
8103       /* Expand prel31 for personality routine.  */
8104       bfd_vma fn;
8105       const char *procname;
8106
8107       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8108       printf (_("  Personality routine: "));
8109       if (fn == 0
8110           && addr.section == SHN_UNDEF && addr.offset == 0
8111           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8112         {
8113           procname = aux->strtab + sym_name;
8114           print_vma (fn, PREFIX_HEX);
8115           if (procname)
8116             {
8117               fputs (" <", stdout);
8118               fputs (procname, stdout);
8119               fputc ('>', stdout);
8120             }
8121         }
8122       else
8123         procname = arm_print_vma_and_name (aux, fn, addr);
8124       fputc ('\n', stdout);
8125
8126       /* The GCC personality routines use the standard compact
8127          encoding, starting with one byte giving the number of
8128          words.  */
8129       if (procname != NULL
8130           && (const_strneq (procname, "__gcc_personality_v0")
8131               || const_strneq (procname, "__gxx_personality_v0")
8132               || const_strneq (procname, "__gcj_personality_v0")
8133               || const_strneq (procname, "__gnu_objc_personality_v0")))
8134         {
8135           remaining = 0;
8136           more_words = 1;
8137           ADVANCE;
8138           if (!remaining)
8139             {
8140               printf (_("  [Truncated data]\n"));
8141               return;
8142             }
8143           more_words = word >> 24;
8144           word <<= 8;
8145           remaining--;
8146           per_index = -1;
8147         }
8148       else
8149         return;
8150     }
8151   else
8152     {
8153       /* ARM EHABI Section 6.3:
8154
8155          An exception-handling table entry for the compact model looks like:
8156
8157            31 30-28 27-24 23-0
8158            -- ----- ----- ----
8159             1   0   index Data for personalityRoutine[index]    */
8160
8161       if (elf_header.e_machine == EM_ARM
8162           && (word & 0x70000000))
8163         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8164
8165       per_index = (word >> 24) & 0x7f;
8166       printf (_("  Compact model index: %d\n"), per_index);
8167       if (per_index == 0)
8168         {
8169           more_words = 0;
8170           word <<= 8;
8171           remaining--;
8172         }
8173       else if (per_index < 3)
8174         {
8175           more_words = (word >> 16) & 0xff;
8176           word <<= 16;
8177           remaining -= 2;
8178         }
8179     }
8180
8181   switch (elf_header.e_machine)
8182     {
8183     case EM_ARM:
8184       if (per_index < 3)
8185         {
8186           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8187                                       data_offset, data_sec, data_arm_sec);
8188         }
8189       else
8190         {
8191           warn (_("Unknown ARM compact model index encountered\n"));
8192           printf (_("  [reserved]\n"));
8193         }
8194       break;
8195
8196     case EM_TI_C6000:
8197       if (per_index < 3)
8198         {
8199           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8200                                         data_offset, data_sec, data_arm_sec);
8201         }
8202       else if (per_index < 5)
8203         {
8204           if (((word >> 17) & 0x7f) == 0x7f)
8205             printf (_("  Restore stack from frame pointer\n"));
8206           else
8207             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8208           printf (_("  Registers restored: "));
8209           if (per_index == 4)
8210             printf (" (compact) ");
8211           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8212           putchar ('\n');
8213           printf (_("  Return register: %s\n"),
8214                   tic6x_unwind_regnames[word & 0xf]);
8215         }
8216       else
8217         printf (_("  [reserved (%d)]\n"), per_index);
8218       break;
8219
8220     default:
8221       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8222              elf_header.e_machine);
8223     }
8224
8225   /* Decode the descriptors.  Not implemented.  */
8226 }
8227
8228 static void
8229 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8230 {
8231   struct arm_section exidx_arm_sec, extab_arm_sec;
8232   unsigned int i, exidx_len;
8233   unsigned long j, nfuns;
8234
8235   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8236   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8237   exidx_len = exidx_sec->sh_size / 8;
8238
8239   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8240   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8241     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8242       aux->funtab[nfuns++] = aux->symtab[j];
8243   aux->nfuns = nfuns;
8244   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8245
8246   for (i = 0; i < exidx_len; i++)
8247     {
8248       unsigned int exidx_fn, exidx_entry;
8249       struct absaddr fn_addr, entry_addr;
8250       bfd_vma fn;
8251
8252       fputc ('\n', stdout);
8253
8254       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8255                                      8 * i, & exidx_fn, & fn_addr, NULL)
8256           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8257                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8258         {
8259           free (aux->funtab);
8260           arm_free_section (& exidx_arm_sec);
8261           arm_free_section (& extab_arm_sec);
8262           return;
8263         }
8264
8265       /* ARM EHABI, Section 5:
8266          An index table entry consists of 2 words.
8267          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8268       if (exidx_fn & 0x80000000)
8269         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8270
8271       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8272
8273       arm_print_vma_and_name (aux, fn, fn_addr);
8274       fputs (": ", stdout);
8275
8276       if (exidx_entry == 1)
8277         {
8278           print_vma (exidx_entry, PREFIX_HEX);
8279           fputs (" [cantunwind]\n", stdout);
8280         }
8281       else if (exidx_entry & 0x80000000)
8282         {
8283           print_vma (exidx_entry, PREFIX_HEX);
8284           fputc ('\n', stdout);
8285           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8286         }
8287       else
8288         {
8289           bfd_vma table, table_offset = 0;
8290           Elf_Internal_Shdr *table_sec;
8291
8292           fputs ("@", stdout);
8293           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8294           print_vma (table, PREFIX_HEX);
8295           printf ("\n");
8296
8297           /* Locate the matching .ARM.extab.  */
8298           if (entry_addr.section != SHN_UNDEF
8299               && entry_addr.section < elf_header.e_shnum)
8300             {
8301               table_sec = section_headers + entry_addr.section;
8302               table_offset = entry_addr.offset;
8303             }
8304           else
8305             {
8306               table_sec = find_section_by_address (table);
8307               if (table_sec != NULL)
8308                 table_offset = table - table_sec->sh_addr;
8309             }
8310           if (table_sec == NULL)
8311             {
8312               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8313                     (unsigned long) table);
8314               continue;
8315             }
8316           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8317                              &extab_arm_sec);
8318         }
8319     }
8320
8321   printf ("\n");
8322
8323   free (aux->funtab);
8324   arm_free_section (&exidx_arm_sec);
8325   arm_free_section (&extab_arm_sec);
8326 }
8327
8328 /* Used for both ARM and C6X unwinding tables.  */
8329
8330 static void
8331 arm_process_unwind (FILE *file)
8332 {
8333   struct arm_unw_aux_info aux;
8334   Elf_Internal_Shdr *unwsec = NULL;
8335   Elf_Internal_Shdr *strsec;
8336   Elf_Internal_Shdr *sec;
8337   unsigned long i;
8338   unsigned int sec_type;
8339
8340   switch (elf_header.e_machine)
8341     {
8342     case EM_ARM:
8343       sec_type = SHT_ARM_EXIDX;
8344       break;
8345
8346     case EM_TI_C6000:
8347       sec_type = SHT_C6000_UNWIND;
8348       break;
8349
8350     default:
8351       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8352              elf_header.e_machine);
8353       return;
8354     }
8355
8356   if (string_table == NULL)
8357     return;
8358
8359   memset (& aux, 0, sizeof (aux));
8360   aux.file = file;
8361
8362   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8363     {
8364       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8365         {
8366           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8367
8368           strsec = section_headers + sec->sh_link;
8369
8370           /* PR binutils/17531 file: 011-12666-0.004.  */
8371           if (aux.strtab != NULL)
8372             {
8373               error (_("Multiple string tables found in file.\n"));
8374               free (aux.strtab);
8375             }
8376           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8377                                  1, strsec->sh_size, _("string table"));
8378           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8379         }
8380       else if (sec->sh_type == sec_type)
8381         unwsec = sec;
8382     }
8383
8384   if (unwsec == NULL)
8385     printf (_("\nThere are no unwind sections in this file.\n"));
8386   else
8387     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8388       {
8389         if (sec->sh_type == sec_type)
8390           {
8391             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8392                     printable_section_name (sec),
8393                     (unsigned long) sec->sh_offset,
8394                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8395
8396             dump_arm_unwind (&aux, sec);
8397           }
8398       }
8399
8400   if (aux.symtab)
8401     free (aux.symtab);
8402   if (aux.strtab)
8403     free ((char *) aux.strtab);
8404 }
8405
8406 static void
8407 process_unwind (FILE * file)
8408 {
8409   struct unwind_handler
8410   {
8411     int machtype;
8412     void (* handler)(FILE *);
8413   } handlers[] =
8414   {
8415     { EM_ARM, arm_process_unwind },
8416     { EM_IA_64, ia64_process_unwind },
8417     { EM_PARISC, hppa_process_unwind },
8418     { EM_TI_C6000, arm_process_unwind },
8419     { 0, 0 }
8420   };
8421   int i;
8422
8423   if (!do_unwind)
8424     return;
8425
8426   for (i = 0; handlers[i].handler != NULL; i++)
8427     if (elf_header.e_machine == handlers[i].machtype)
8428       {
8429         handlers[i].handler (file);
8430         return;
8431       }
8432
8433   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8434           get_machine_name (elf_header.e_machine));
8435 }
8436
8437 static void
8438 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8439 {
8440   switch (entry->d_tag)
8441     {
8442     case DT_MIPS_FLAGS:
8443       if (entry->d_un.d_val == 0)
8444         printf (_("NONE"));
8445       else
8446         {
8447           static const char * opts[] =
8448           {
8449             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8450             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8451             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8452             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8453             "RLD_ORDER_SAFE"
8454           };
8455           unsigned int cnt;
8456           int first = 1;
8457
8458           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8459             if (entry->d_un.d_val & (1 << cnt))
8460               {
8461                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8462                 first = 0;
8463               }
8464         }
8465       break;
8466
8467     case DT_MIPS_IVERSION:
8468       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8469         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8470       else
8471         {
8472           char buf[40];
8473           sprintf_vma (buf, entry->d_un.d_ptr);
8474           /* Note: coded this way so that there is a single string for translation.  */
8475           printf (_("<corrupt: %s>"), buf);
8476         }
8477       break;
8478
8479     case DT_MIPS_TIME_STAMP:
8480       {
8481         char timebuf[20];
8482         struct tm * tmp;
8483         time_t atime = entry->d_un.d_val;
8484
8485         tmp = gmtime (&atime);
8486         /* PR 17531: file: 6accc532.  */
8487         if (tmp == NULL)
8488           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8489         else
8490           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8491                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8492                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8493         printf (_("Time Stamp: %s"), timebuf);
8494       }
8495       break;
8496
8497     case DT_MIPS_RLD_VERSION:
8498     case DT_MIPS_LOCAL_GOTNO:
8499     case DT_MIPS_CONFLICTNO:
8500     case DT_MIPS_LIBLISTNO:
8501     case DT_MIPS_SYMTABNO:
8502     case DT_MIPS_UNREFEXTNO:
8503     case DT_MIPS_HIPAGENO:
8504     case DT_MIPS_DELTA_CLASS_NO:
8505     case DT_MIPS_DELTA_INSTANCE_NO:
8506     case DT_MIPS_DELTA_RELOC_NO:
8507     case DT_MIPS_DELTA_SYM_NO:
8508     case DT_MIPS_DELTA_CLASSSYM_NO:
8509     case DT_MIPS_COMPACT_SIZE:
8510       print_vma (entry->d_un.d_ptr, DEC);
8511       break;
8512
8513     default:
8514       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8515     }
8516     putchar ('\n');
8517 }
8518
8519 static void
8520 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8521 {
8522   switch (entry->d_tag)
8523     {
8524     case DT_HP_DLD_FLAGS:
8525       {
8526         static struct
8527         {
8528           long int bit;
8529           const char * str;
8530         }
8531         flags[] =
8532         {
8533           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8534           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8535           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8536           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8537           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8538           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8539           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8540           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8541           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8542           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8543           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8544           { DT_HP_GST, "HP_GST" },
8545           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8546           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8547           { DT_HP_NODELETE, "HP_NODELETE" },
8548           { DT_HP_GROUP, "HP_GROUP" },
8549           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8550         };
8551         int first = 1;
8552         size_t cnt;
8553         bfd_vma val = entry->d_un.d_val;
8554
8555         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8556           if (val & flags[cnt].bit)
8557             {
8558               if (! first)
8559                 putchar (' ');
8560               fputs (flags[cnt].str, stdout);
8561               first = 0;
8562               val ^= flags[cnt].bit;
8563             }
8564
8565         if (val != 0 || first)
8566           {
8567             if (! first)
8568               putchar (' ');
8569             print_vma (val, HEX);
8570           }
8571       }
8572       break;
8573
8574     default:
8575       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8576       break;
8577     }
8578   putchar ('\n');
8579 }
8580
8581 #ifdef BFD64
8582
8583 /* VMS vs Unix time offset and factor.  */
8584
8585 #define VMS_EPOCH_OFFSET 35067168000000000LL
8586 #define VMS_GRANULARITY_FACTOR 10000000
8587
8588 /* Display a VMS time in a human readable format.  */
8589
8590 static void
8591 print_vms_time (bfd_int64_t vmstime)
8592 {
8593   struct tm *tm;
8594   time_t unxtime;
8595
8596   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8597   tm = gmtime (&unxtime);
8598   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8599           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8600           tm->tm_hour, tm->tm_min, tm->tm_sec);
8601 }
8602 #endif /* BFD64 */
8603
8604 static void
8605 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8606 {
8607   switch (entry->d_tag)
8608     {
8609     case DT_IA_64_PLT_RESERVE:
8610       /* First 3 slots reserved.  */
8611       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8612       printf (" -- ");
8613       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8614       break;
8615
8616     case DT_IA_64_VMS_LINKTIME:
8617 #ifdef BFD64
8618       print_vms_time (entry->d_un.d_val);
8619 #endif
8620       break;
8621
8622     case DT_IA_64_VMS_LNKFLAGS:
8623       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8624       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8625         printf (" CALL_DEBUG");
8626       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8627         printf (" NOP0BUFS");
8628       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8629         printf (" P0IMAGE");
8630       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8631         printf (" MKTHREADS");
8632       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8633         printf (" UPCALLS");
8634       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8635         printf (" IMGSTA");
8636       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8637         printf (" INITIALIZE");
8638       if (entry->d_un.d_val & VMS_LF_MAIN)
8639         printf (" MAIN");
8640       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8641         printf (" EXE_INIT");
8642       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8643         printf (" TBK_IN_IMG");
8644       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8645         printf (" DBG_IN_IMG");
8646       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8647         printf (" TBK_IN_DSF");
8648       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8649         printf (" DBG_IN_DSF");
8650       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8651         printf (" SIGNATURES");
8652       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8653         printf (" REL_SEG_OFF");
8654       break;
8655
8656     default:
8657       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8658       break;
8659     }
8660   putchar ('\n');
8661 }
8662
8663 static int
8664 get_32bit_dynamic_section (FILE * file)
8665 {
8666   Elf32_External_Dyn * edyn;
8667   Elf32_External_Dyn * ext;
8668   Elf_Internal_Dyn * entry;
8669
8670   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8671                                           dynamic_size, _("dynamic section"));
8672   if (!edyn)
8673     return 0;
8674
8675   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8676      might not have the luxury of section headers.  Look for the DT_NULL
8677      terminator to determine the number of entries.  */
8678   for (ext = edyn, dynamic_nent = 0;
8679        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8680        ext++)
8681     {
8682       dynamic_nent++;
8683       if (BYTE_GET (ext->d_tag) == DT_NULL)
8684         break;
8685     }
8686
8687   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8688                                                   sizeof (* entry));
8689   if (dynamic_section == NULL)
8690     {
8691       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8692              (unsigned long) dynamic_nent);
8693       free (edyn);
8694       return 0;
8695     }
8696
8697   for (ext = edyn, entry = dynamic_section;
8698        entry < dynamic_section + dynamic_nent;
8699        ext++, entry++)
8700     {
8701       entry->d_tag      = BYTE_GET (ext->d_tag);
8702       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8703     }
8704
8705   free (edyn);
8706
8707   return 1;
8708 }
8709
8710 static int
8711 get_64bit_dynamic_section (FILE * file)
8712 {
8713   Elf64_External_Dyn * edyn;
8714   Elf64_External_Dyn * ext;
8715   Elf_Internal_Dyn * entry;
8716
8717   /* Read in the data.  */
8718   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8719                                           dynamic_size, _("dynamic section"));
8720   if (!edyn)
8721     return 0;
8722
8723   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8724      might not have the luxury of section headers.  Look for the DT_NULL
8725      terminator to determine the number of entries.  */
8726   for (ext = edyn, dynamic_nent = 0;
8727        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8728        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8729        ext++)
8730     {
8731       dynamic_nent++;
8732       if (BYTE_GET (ext->d_tag) == DT_NULL)
8733         break;
8734     }
8735
8736   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8737                                                   sizeof (* entry));
8738   if (dynamic_section == NULL)
8739     {
8740       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8741              (unsigned long) dynamic_nent);
8742       free (edyn);
8743       return 0;
8744     }
8745
8746   /* Convert from external to internal formats.  */
8747   for (ext = edyn, entry = dynamic_section;
8748        entry < dynamic_section + dynamic_nent;
8749        ext++, entry++)
8750     {
8751       entry->d_tag      = BYTE_GET (ext->d_tag);
8752       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8753     }
8754
8755   free (edyn);
8756
8757   return 1;
8758 }
8759
8760 static void
8761 print_dynamic_flags (bfd_vma flags)
8762 {
8763   int first = 1;
8764
8765   while (flags)
8766     {
8767       bfd_vma flag;
8768
8769       flag = flags & - flags;
8770       flags &= ~ flag;
8771
8772       if (first)
8773         first = 0;
8774       else
8775         putc (' ', stdout);
8776
8777       switch (flag)
8778         {
8779         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8780         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8781         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8782         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8783         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8784         default:                fputs (_("unknown"), stdout); break;
8785         }
8786     }
8787   puts ("");
8788 }
8789
8790 /* Parse and display the contents of the dynamic section.  */
8791
8792 static int
8793 process_dynamic_section (FILE * file)
8794 {
8795   Elf_Internal_Dyn * entry;
8796
8797   if (dynamic_size == 0)
8798     {
8799       if (do_dynamic)
8800         printf (_("\nThere is no dynamic section in this file.\n"));
8801
8802       return 1;
8803     }
8804
8805   if (is_32bit_elf)
8806     {
8807       if (! get_32bit_dynamic_section (file))
8808         return 0;
8809     }
8810   else if (! get_64bit_dynamic_section (file))
8811     return 0;
8812
8813   /* Find the appropriate symbol table.  */
8814   if (dynamic_symbols == NULL)
8815     {
8816       for (entry = dynamic_section;
8817            entry < dynamic_section + dynamic_nent;
8818            ++entry)
8819         {
8820           Elf_Internal_Shdr section;
8821
8822           if (entry->d_tag != DT_SYMTAB)
8823             continue;
8824
8825           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8826
8827           /* Since we do not know how big the symbol table is,
8828              we default to reading in the entire file (!) and
8829              processing that.  This is overkill, I know, but it
8830              should work.  */
8831           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8832
8833           if (archive_file_offset != 0)
8834             section.sh_size = archive_file_size - section.sh_offset;
8835           else
8836             {
8837               if (fseek (file, 0, SEEK_END))
8838                 error (_("Unable to seek to end of file!\n"));
8839
8840               section.sh_size = ftell (file) - section.sh_offset;
8841             }
8842
8843           if (is_32bit_elf)
8844             section.sh_entsize = sizeof (Elf32_External_Sym);
8845           else
8846             section.sh_entsize = sizeof (Elf64_External_Sym);
8847           section.sh_name = string_table_length;
8848
8849           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8850           if (num_dynamic_syms < 1)
8851             {
8852               error (_("Unable to determine the number of symbols to load\n"));
8853               continue;
8854             }
8855         }
8856     }
8857
8858   /* Similarly find a string table.  */
8859   if (dynamic_strings == NULL)
8860     {
8861       for (entry = dynamic_section;
8862            entry < dynamic_section + dynamic_nent;
8863            ++entry)
8864         {
8865           unsigned long offset;
8866           long str_tab_len;
8867
8868           if (entry->d_tag != DT_STRTAB)
8869             continue;
8870
8871           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8872
8873           /* Since we do not know how big the string table is,
8874              we default to reading in the entire file (!) and
8875              processing that.  This is overkill, I know, but it
8876              should work.  */
8877
8878           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8879
8880           if (archive_file_offset != 0)
8881             str_tab_len = archive_file_size - offset;
8882           else
8883             {
8884               if (fseek (file, 0, SEEK_END))
8885                 error (_("Unable to seek to end of file\n"));
8886               str_tab_len = ftell (file) - offset;
8887             }
8888
8889           if (str_tab_len < 1)
8890             {
8891               error
8892                 (_("Unable to determine the length of the dynamic string table\n"));
8893               continue;
8894             }
8895
8896           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8897                                                str_tab_len,
8898                                                _("dynamic string table"));
8899           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8900           break;
8901         }
8902     }
8903
8904   /* And find the syminfo section if available.  */
8905   if (dynamic_syminfo == NULL)
8906     {
8907       unsigned long syminsz = 0;
8908
8909       for (entry = dynamic_section;
8910            entry < dynamic_section + dynamic_nent;
8911            ++entry)
8912         {
8913           if (entry->d_tag == DT_SYMINENT)
8914             {
8915               /* Note: these braces are necessary to avoid a syntax
8916                  error from the SunOS4 C compiler.  */
8917               /* PR binutils/17531: A corrupt file can trigger this test.
8918                  So do not use an assert, instead generate an error message.  */
8919               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8920                 error (_("Bad value (%d) for SYMINENT entry\n"),
8921                        (int) entry->d_un.d_val);
8922             }
8923           else if (entry->d_tag == DT_SYMINSZ)
8924             syminsz = entry->d_un.d_val;
8925           else if (entry->d_tag == DT_SYMINFO)
8926             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8927                                                       syminsz);
8928         }
8929
8930       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8931         {
8932           Elf_External_Syminfo * extsyminfo;
8933           Elf_External_Syminfo * extsym;
8934           Elf_Internal_Syminfo * syminfo;
8935
8936           /* There is a syminfo section.  Read the data.  */
8937           extsyminfo = (Elf_External_Syminfo *)
8938               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8939                         _("symbol information"));
8940           if (!extsyminfo)
8941             return 0;
8942
8943           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8944           if (dynamic_syminfo == NULL)
8945             {
8946               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8947                      (unsigned long) syminsz);
8948               return 0;
8949             }
8950
8951           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8952           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8953                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8954                ++syminfo, ++extsym)
8955             {
8956               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8957               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8958             }
8959
8960           free (extsyminfo);
8961         }
8962     }
8963
8964   if (do_dynamic && dynamic_addr)
8965     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8966             dynamic_addr, (unsigned long) dynamic_nent);
8967   if (do_dynamic)
8968     printf (_("  Tag        Type                         Name/Value\n"));
8969
8970   for (entry = dynamic_section;
8971        entry < dynamic_section + dynamic_nent;
8972        entry++)
8973     {
8974       if (do_dynamic)
8975         {
8976           const char * dtype;
8977
8978           putchar (' ');
8979           print_vma (entry->d_tag, FULL_HEX);
8980           dtype = get_dynamic_type (entry->d_tag);
8981           printf (" (%s)%*s", dtype,
8982                   ((is_32bit_elf ? 27 : 19)
8983                    - (int) strlen (dtype)),
8984                   " ");
8985         }
8986
8987       switch (entry->d_tag)
8988         {
8989         case DT_FLAGS:
8990           if (do_dynamic)
8991             print_dynamic_flags (entry->d_un.d_val);
8992           break;
8993
8994         case DT_AUXILIARY:
8995         case DT_FILTER:
8996         case DT_CONFIG:
8997         case DT_DEPAUDIT:
8998         case DT_AUDIT:
8999           if (do_dynamic)
9000             {
9001               switch (entry->d_tag)
9002                 {
9003                 case DT_AUXILIARY:
9004                   printf (_("Auxiliary library"));
9005                   break;
9006
9007                 case DT_FILTER:
9008                   printf (_("Filter library"));
9009                   break;
9010
9011                 case DT_CONFIG:
9012                   printf (_("Configuration file"));
9013                   break;
9014
9015                 case DT_DEPAUDIT:
9016                   printf (_("Dependency audit library"));
9017                   break;
9018
9019                 case DT_AUDIT:
9020                   printf (_("Audit library"));
9021                   break;
9022                 }
9023
9024               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9025                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9026               else
9027                 {
9028                   printf (": ");
9029                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9030                   putchar ('\n');
9031                 }
9032             }
9033           break;
9034
9035         case DT_FEATURE:
9036           if (do_dynamic)
9037             {
9038               printf (_("Flags:"));
9039
9040               if (entry->d_un.d_val == 0)
9041                 printf (_(" None\n"));
9042               else
9043                 {
9044                   unsigned long int val = entry->d_un.d_val;
9045
9046                   if (val & DTF_1_PARINIT)
9047                     {
9048                       printf (" PARINIT");
9049                       val ^= DTF_1_PARINIT;
9050                     }
9051                   if (val & DTF_1_CONFEXP)
9052                     {
9053                       printf (" CONFEXP");
9054                       val ^= DTF_1_CONFEXP;
9055                     }
9056                   if (val != 0)
9057                     printf (" %lx", val);
9058                   puts ("");
9059                 }
9060             }
9061           break;
9062
9063         case DT_POSFLAG_1:
9064           if (do_dynamic)
9065             {
9066               printf (_("Flags:"));
9067
9068               if (entry->d_un.d_val == 0)
9069                 printf (_(" None\n"));
9070               else
9071                 {
9072                   unsigned long int val = entry->d_un.d_val;
9073
9074                   if (val & DF_P1_LAZYLOAD)
9075                     {
9076                       printf (" LAZYLOAD");
9077                       val ^= DF_P1_LAZYLOAD;
9078                     }
9079                   if (val & DF_P1_GROUPPERM)
9080                     {
9081                       printf (" GROUPPERM");
9082                       val ^= DF_P1_GROUPPERM;
9083                     }
9084                   if (val != 0)
9085                     printf (" %lx", val);
9086                   puts ("");
9087                 }
9088             }
9089           break;
9090
9091         case DT_FLAGS_1:
9092           if (do_dynamic)
9093             {
9094               printf (_("Flags:"));
9095               if (entry->d_un.d_val == 0)
9096                 printf (_(" None\n"));
9097               else
9098                 {
9099                   unsigned long int val = entry->d_un.d_val;
9100
9101                   if (val & DF_1_NOW)
9102                     {
9103                       printf (" NOW");
9104                       val ^= DF_1_NOW;
9105                     }
9106                   if (val & DF_1_GLOBAL)
9107                     {
9108                       printf (" GLOBAL");
9109                       val ^= DF_1_GLOBAL;
9110                     }
9111                   if (val & DF_1_GROUP)
9112                     {
9113                       printf (" GROUP");
9114                       val ^= DF_1_GROUP;
9115                     }
9116                   if (val & DF_1_NODELETE)
9117                     {
9118                       printf (" NODELETE");
9119                       val ^= DF_1_NODELETE;
9120                     }
9121                   if (val & DF_1_LOADFLTR)
9122                     {
9123                       printf (" LOADFLTR");
9124                       val ^= DF_1_LOADFLTR;
9125                     }
9126                   if (val & DF_1_INITFIRST)
9127                     {
9128                       printf (" INITFIRST");
9129                       val ^= DF_1_INITFIRST;
9130                     }
9131                   if (val & DF_1_NOOPEN)
9132                     {
9133                       printf (" NOOPEN");
9134                       val ^= DF_1_NOOPEN;
9135                     }
9136                   if (val & DF_1_ORIGIN)
9137                     {
9138                       printf (" ORIGIN");
9139                       val ^= DF_1_ORIGIN;
9140                     }
9141                   if (val & DF_1_DIRECT)
9142                     {
9143                       printf (" DIRECT");
9144                       val ^= DF_1_DIRECT;
9145                     }
9146                   if (val & DF_1_TRANS)
9147                     {
9148                       printf (" TRANS");
9149                       val ^= DF_1_TRANS;
9150                     }
9151                   if (val & DF_1_INTERPOSE)
9152                     {
9153                       printf (" INTERPOSE");
9154                       val ^= DF_1_INTERPOSE;
9155                     }
9156                   if (val & DF_1_NODEFLIB)
9157                     {
9158                       printf (" NODEFLIB");
9159                       val ^= DF_1_NODEFLIB;
9160                     }
9161                   if (val & DF_1_NODUMP)
9162                     {
9163                       printf (" NODUMP");
9164                       val ^= DF_1_NODUMP;
9165                     }
9166                   if (val & DF_1_CONFALT)
9167                     {
9168                       printf (" CONFALT");
9169                       val ^= DF_1_CONFALT;
9170                     }
9171                   if (val & DF_1_ENDFILTEE)
9172                     {
9173                       printf (" ENDFILTEE");
9174                       val ^= DF_1_ENDFILTEE;
9175                     }
9176                   if (val & DF_1_DISPRELDNE)
9177                     {
9178                       printf (" DISPRELDNE");
9179                       val ^= DF_1_DISPRELDNE;
9180                     }
9181                   if (val & DF_1_DISPRELPND)
9182                     {
9183                       printf (" DISPRELPND");
9184                       val ^= DF_1_DISPRELPND;
9185                     }
9186                   if (val & DF_1_NODIRECT)
9187                     {
9188                       printf (" NODIRECT");
9189                       val ^= DF_1_NODIRECT;
9190                     }
9191                   if (val & DF_1_IGNMULDEF)
9192                     {
9193                       printf (" IGNMULDEF");
9194                       val ^= DF_1_IGNMULDEF;
9195                     }
9196                   if (val & DF_1_NOKSYMS)
9197                     {
9198                       printf (" NOKSYMS");
9199                       val ^= DF_1_NOKSYMS;
9200                     }
9201                   if (val & DF_1_NOHDR)
9202                     {
9203                       printf (" NOHDR");
9204                       val ^= DF_1_NOHDR;
9205                     }
9206                   if (val & DF_1_EDITED)
9207                     {
9208                       printf (" EDITED");
9209                       val ^= DF_1_EDITED;
9210                     }
9211                   if (val & DF_1_NORELOC)
9212                     {
9213                       printf (" NORELOC");
9214                       val ^= DF_1_NORELOC;
9215                     }
9216                   if (val & DF_1_SYMINTPOSE)
9217                     {
9218                       printf (" SYMINTPOSE");
9219                       val ^= DF_1_SYMINTPOSE;
9220                     }
9221                   if (val & DF_1_GLOBAUDIT)
9222                     {
9223                       printf (" GLOBAUDIT");
9224                       val ^= DF_1_GLOBAUDIT;
9225                     }
9226                   if (val & DF_1_SINGLETON)
9227                     {
9228                       printf (" SINGLETON");
9229                       val ^= DF_1_SINGLETON;
9230                     }
9231                   if (val != 0)
9232                     printf (" %lx", val);
9233                   puts ("");
9234                 }
9235             }
9236           break;
9237
9238         case DT_PLTREL:
9239           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9240           if (do_dynamic)
9241             puts (get_dynamic_type (entry->d_un.d_val));
9242           break;
9243
9244         case DT_NULL    :
9245         case DT_NEEDED  :
9246         case DT_PLTGOT  :
9247         case DT_HASH    :
9248         case DT_STRTAB  :
9249         case DT_SYMTAB  :
9250         case DT_RELA    :
9251         case DT_INIT    :
9252         case DT_FINI    :
9253         case DT_SONAME  :
9254         case DT_RPATH   :
9255         case DT_SYMBOLIC:
9256         case DT_REL     :
9257         case DT_DEBUG   :
9258         case DT_TEXTREL :
9259         case DT_JMPREL  :
9260         case DT_RUNPATH :
9261           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9262
9263           if (do_dynamic)
9264             {
9265               char * name;
9266
9267               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9268                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9269               else
9270                 name = NULL;
9271
9272               if (name)
9273                 {
9274                   switch (entry->d_tag)
9275                     {
9276                     case DT_NEEDED:
9277                       printf (_("Shared library: [%s]"), name);
9278
9279                       if (streq (name, program_interpreter))
9280                         printf (_(" program interpreter"));
9281                       break;
9282
9283                     case DT_SONAME:
9284                       printf (_("Library soname: [%s]"), name);
9285                       break;
9286
9287                     case DT_RPATH:
9288                       printf (_("Library rpath: [%s]"), name);
9289                       break;
9290
9291                     case DT_RUNPATH:
9292                       printf (_("Library runpath: [%s]"), name);
9293                       break;
9294
9295                     default:
9296                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9297                       break;
9298                     }
9299                 }
9300               else
9301                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9302
9303               putchar ('\n');
9304             }
9305           break;
9306
9307         case DT_PLTRELSZ:
9308         case DT_RELASZ  :
9309         case DT_STRSZ   :
9310         case DT_RELSZ   :
9311         case DT_RELAENT :
9312         case DT_SYMENT  :
9313         case DT_RELENT  :
9314           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9315         case DT_PLTPADSZ:
9316         case DT_MOVEENT :
9317         case DT_MOVESZ  :
9318         case DT_INIT_ARRAYSZ:
9319         case DT_FINI_ARRAYSZ:
9320         case DT_GNU_CONFLICTSZ:
9321         case DT_GNU_LIBLISTSZ:
9322           if (do_dynamic)
9323             {
9324               print_vma (entry->d_un.d_val, UNSIGNED);
9325               printf (_(" (bytes)\n"));
9326             }
9327           break;
9328
9329         case DT_VERDEFNUM:
9330         case DT_VERNEEDNUM:
9331         case DT_RELACOUNT:
9332         case DT_RELCOUNT:
9333           if (do_dynamic)
9334             {
9335               print_vma (entry->d_un.d_val, UNSIGNED);
9336               putchar ('\n');
9337             }
9338           break;
9339
9340         case DT_SYMINSZ:
9341         case DT_SYMINENT:
9342         case DT_SYMINFO:
9343         case DT_USED:
9344         case DT_INIT_ARRAY:
9345         case DT_FINI_ARRAY:
9346           if (do_dynamic)
9347             {
9348               if (entry->d_tag == DT_USED
9349                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9350                 {
9351                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9352
9353                   if (*name)
9354                     {
9355                       printf (_("Not needed object: [%s]\n"), name);
9356                       break;
9357                     }
9358                 }
9359
9360               print_vma (entry->d_un.d_val, PREFIX_HEX);
9361               putchar ('\n');
9362             }
9363           break;
9364
9365         case DT_BIND_NOW:
9366           /* The value of this entry is ignored.  */
9367           if (do_dynamic)
9368             putchar ('\n');
9369           break;
9370
9371         case DT_GNU_PRELINKED:
9372           if (do_dynamic)
9373             {
9374               struct tm * tmp;
9375               time_t atime = entry->d_un.d_val;
9376
9377               tmp = gmtime (&atime);
9378               /* PR 17533 file: 041-1244816-0.004.  */
9379               if (tmp == NULL)
9380                 printf (_("<corrupt time val: %lx"),
9381                         (unsigned long) atime);
9382               else
9383                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9384                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9385                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9386
9387             }
9388           break;
9389
9390         case DT_GNU_HASH:
9391           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9392           if (do_dynamic)
9393             {
9394               print_vma (entry->d_un.d_val, PREFIX_HEX);
9395               putchar ('\n');
9396             }
9397           break;
9398
9399         default:
9400           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9401             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9402               entry->d_un.d_val;
9403
9404           if (do_dynamic)
9405             {
9406               switch (elf_header.e_machine)
9407                 {
9408                 case EM_MIPS:
9409                 case EM_MIPS_RS3_LE:
9410                   dynamic_section_mips_val (entry);
9411                   break;
9412                 case EM_PARISC:
9413                   dynamic_section_parisc_val (entry);
9414                   break;
9415                 case EM_IA_64:
9416                   dynamic_section_ia64_val (entry);
9417                   break;
9418                 default:
9419                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9420                   putchar ('\n');
9421                 }
9422             }
9423           break;
9424         }
9425     }
9426
9427   return 1;
9428 }
9429
9430 static char *
9431 get_ver_flags (unsigned int flags)
9432 {
9433   static char buff[32];
9434
9435   buff[0] = 0;
9436
9437   if (flags == 0)
9438     return _("none");
9439
9440   if (flags & VER_FLG_BASE)
9441     strcat (buff, "BASE ");
9442
9443   if (flags & VER_FLG_WEAK)
9444     {
9445       if (flags & VER_FLG_BASE)
9446         strcat (buff, "| ");
9447
9448       strcat (buff, "WEAK ");
9449     }
9450
9451   if (flags & VER_FLG_INFO)
9452     {
9453       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9454         strcat (buff, "| ");
9455
9456       strcat (buff, "INFO ");
9457     }
9458
9459   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9460     strcat (buff, _("| <unknown>"));
9461
9462   return buff;
9463 }
9464
9465 /* Display the contents of the version sections.  */
9466
9467 static int
9468 process_version_sections (FILE * file)
9469 {
9470   Elf_Internal_Shdr * section;
9471   unsigned i;
9472   int found = 0;
9473
9474   if (! do_version)
9475     return 1;
9476
9477   for (i = 0, section = section_headers;
9478        i < elf_header.e_shnum;
9479        i++, section++)
9480     {
9481       switch (section->sh_type)
9482         {
9483         case SHT_GNU_verdef:
9484           {
9485             Elf_External_Verdef * edefs;
9486             unsigned int idx;
9487             unsigned int cnt;
9488             char * endbuf;
9489
9490             found = 1;
9491
9492             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9493                     printable_section_name (section),
9494                     section->sh_info);
9495
9496             printf (_("  Addr: 0x"));
9497             printf_vma (section->sh_addr);
9498             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9499                     (unsigned long) section->sh_offset, section->sh_link,
9500                     printable_section_name_from_index (section->sh_link));
9501
9502             edefs = (Elf_External_Verdef *)
9503                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9504                           _("version definition section"));
9505             if (!edefs)
9506               break;
9507             endbuf = (char *) edefs + section->sh_size;
9508
9509             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9510               {
9511                 char * vstart;
9512                 Elf_External_Verdef * edef;
9513                 Elf_Internal_Verdef ent;
9514                 Elf_External_Verdaux * eaux;
9515                 Elf_Internal_Verdaux aux;
9516                 int j;
9517                 int isum;
9518
9519                 /* Check for very large indicies.  */
9520                 if (idx > (size_t) (endbuf - (char *) edefs))
9521                   break;
9522
9523                 vstart = ((char *) edefs) + idx;
9524                 if (vstart + sizeof (*edef) > endbuf)
9525                   break;
9526
9527                 edef = (Elf_External_Verdef *) vstart;
9528
9529                 ent.vd_version = BYTE_GET (edef->vd_version);
9530                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9531                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9532                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9533                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9534                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9535                 ent.vd_next    = BYTE_GET (edef->vd_next);
9536
9537                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9538                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9539
9540                 printf (_("  Index: %d  Cnt: %d  "),
9541                         ent.vd_ndx, ent.vd_cnt);
9542
9543                 /* Check for overflow.  */
9544                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9545                   break;
9546
9547                 vstart += ent.vd_aux;
9548
9549                 eaux = (Elf_External_Verdaux *) vstart;
9550
9551                 aux.vda_name = BYTE_GET (eaux->vda_name);
9552                 aux.vda_next = BYTE_GET (eaux->vda_next);
9553
9554                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9555                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9556                 else
9557                   printf (_("Name index: %ld\n"), aux.vda_name);
9558
9559                 isum = idx + ent.vd_aux;
9560
9561                 for (j = 1; j < ent.vd_cnt; j++)
9562                   {
9563                     /* Check for overflow.  */
9564                     if (aux.vda_next > (size_t) (endbuf - vstart))
9565                       break;
9566
9567                     isum   += aux.vda_next;
9568                     vstart += aux.vda_next;
9569
9570                     eaux = (Elf_External_Verdaux *) vstart;
9571                     if (vstart + sizeof (*eaux) > endbuf)
9572                       break;
9573
9574                     aux.vda_name = BYTE_GET (eaux->vda_name);
9575                     aux.vda_next = BYTE_GET (eaux->vda_next);
9576
9577                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9578                       printf (_("  %#06x: Parent %d: %s\n"),
9579                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9580                     else
9581                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9582                               isum, j, aux.vda_name);
9583                   }
9584
9585                 if (j < ent.vd_cnt)
9586                   printf (_("  Version def aux past end of section\n"));
9587
9588                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9589                 if (idx + ent.vd_next <= idx)
9590                   break;
9591
9592                 idx += ent.vd_next;
9593               }
9594
9595             if (cnt < section->sh_info)
9596               printf (_("  Version definition past end of section\n"));
9597
9598             free (edefs);
9599           }
9600           break;
9601
9602         case SHT_GNU_verneed:
9603           {
9604             Elf_External_Verneed * eneed;
9605             unsigned int idx;
9606             unsigned int cnt;
9607             char * endbuf;
9608
9609             found = 1;
9610
9611             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9612                     printable_section_name (section), section->sh_info);
9613
9614             printf (_(" Addr: 0x"));
9615             printf_vma (section->sh_addr);
9616             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9617                     (unsigned long) section->sh_offset, section->sh_link,
9618                     printable_section_name_from_index (section->sh_link));
9619
9620             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9621                                                        section->sh_offset, 1,
9622                                                        section->sh_size,
9623                                                        _("Version Needs section"));
9624             if (!eneed)
9625               break;
9626             endbuf = (char *) eneed + section->sh_size;
9627
9628             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9629               {
9630                 Elf_External_Verneed * entry;
9631                 Elf_Internal_Verneed ent;
9632                 int j;
9633                 int isum;
9634                 char * vstart;
9635
9636                 if (idx > (size_t) (endbuf - (char *) eneed))
9637                   break;
9638
9639                 vstart = ((char *) eneed) + idx;
9640                 if (vstart + sizeof (*entry) > endbuf)
9641                   break;
9642
9643                 entry = (Elf_External_Verneed *) vstart;
9644
9645                 ent.vn_version = BYTE_GET (entry->vn_version);
9646                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9647                 ent.vn_file    = BYTE_GET (entry->vn_file);
9648                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9649                 ent.vn_next    = BYTE_GET (entry->vn_next);
9650
9651                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9652
9653                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9654                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9655                 else
9656                   printf (_("  File: %lx"), ent.vn_file);
9657
9658                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9659
9660                 /* Check for overflow.  */
9661                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9662                   break;
9663                 vstart += ent.vn_aux;
9664
9665                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9666                   {
9667                     Elf_External_Vernaux * eaux;
9668                     Elf_Internal_Vernaux aux;
9669
9670                     if (vstart + sizeof (*eaux) > endbuf)
9671                       break;
9672                     eaux = (Elf_External_Vernaux *) vstart;
9673
9674                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9675                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9676                     aux.vna_other = BYTE_GET (eaux->vna_other);
9677                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9678                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9679
9680                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9681                       printf (_("  %#06x:   Name: %s"),
9682                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9683                     else
9684                       printf (_("  %#06x:   Name index: %lx"),
9685                               isum, aux.vna_name);
9686
9687                     printf (_("  Flags: %s  Version: %d\n"),
9688                             get_ver_flags (aux.vna_flags), aux.vna_other);
9689
9690                     /* Check for overflow.  */
9691                     if (aux.vna_next > (size_t) (endbuf - vstart)
9692                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9693                       {
9694                         warn (_("Invalid vna_next field of %lx\n"),
9695                               aux.vna_next);
9696                         j = ent.vn_cnt;
9697                         break;
9698                       }
9699                     isum   += aux.vna_next;
9700                     vstart += aux.vna_next;
9701                   }
9702
9703                 if (j < ent.vn_cnt)
9704                   warn (_("Missing Version Needs auxillary information\n"));
9705
9706                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9707                   {
9708                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9709                     cnt = section->sh_info;
9710                     break;
9711                   }
9712                 idx += ent.vn_next;
9713               }
9714
9715             if (cnt < section->sh_info)
9716               warn (_("Missing Version Needs information\n"));
9717
9718             free (eneed);
9719           }
9720           break;
9721
9722         case SHT_GNU_versym:
9723           {
9724             Elf_Internal_Shdr * link_section;
9725             size_t total;
9726             unsigned int cnt;
9727             unsigned char * edata;
9728             unsigned short * data;
9729             char * strtab;
9730             Elf_Internal_Sym * symbols;
9731             Elf_Internal_Shdr * string_sec;
9732             unsigned long num_syms;
9733             long off;
9734
9735             if (section->sh_link >= elf_header.e_shnum)
9736               break;
9737
9738             link_section = section_headers + section->sh_link;
9739             total = section->sh_size / sizeof (Elf_External_Versym);
9740
9741             if (link_section->sh_link >= elf_header.e_shnum)
9742               break;
9743
9744             found = 1;
9745
9746             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9747             if (symbols == NULL)
9748               break;
9749
9750             string_sec = section_headers + link_section->sh_link;
9751
9752             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9753                                         string_sec->sh_size,
9754                                         _("version string table"));
9755             if (!strtab)
9756               {
9757                 free (symbols);
9758                 break;
9759               }
9760
9761             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9762                     printable_section_name (section), (unsigned long) total);
9763
9764             printf (_(" Addr: "));
9765             printf_vma (section->sh_addr);
9766             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9767                     (unsigned long) section->sh_offset, section->sh_link,
9768                     printable_section_name (link_section));
9769
9770             off = offset_from_vma (file,
9771                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9772                                    total * sizeof (short));
9773             edata = (unsigned char *) get_data (NULL, file, off, total,
9774                                                 sizeof (short),
9775                                                 _("version symbol data"));
9776             if (!edata)
9777               {
9778                 free (strtab);
9779                 free (symbols);
9780                 break;
9781               }
9782
9783             data = (short unsigned int *) cmalloc (total, sizeof (short));
9784
9785             for (cnt = total; cnt --;)
9786               data[cnt] = byte_get (edata + cnt * sizeof (short),
9787                                     sizeof (short));
9788
9789             free (edata);
9790
9791             for (cnt = 0; cnt < total; cnt += 4)
9792               {
9793                 int j, nn;
9794                 int check_def, check_need;
9795                 char * name;
9796
9797                 printf ("  %03x:", cnt);
9798
9799                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9800                   switch (data[cnt + j])
9801                     {
9802                     case 0:
9803                       fputs (_("   0 (*local*)    "), stdout);
9804                       break;
9805
9806                     case 1:
9807                       fputs (_("   1 (*global*)   "), stdout);
9808                       break;
9809
9810                     default:
9811                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9812                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9813
9814                       /* If this index value is greater than the size of the symbols
9815                          array, break to avoid an out-of-bounds read.  */
9816                       if ((unsigned long)(cnt + j) >= num_syms)
9817                         {
9818                           warn (_("invalid index into symbol array\n"));
9819                           break;
9820                         }
9821
9822                       check_def = 1;
9823                       check_need = 1;
9824                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9825                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9826                              != SHT_NOBITS)
9827                         {
9828                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9829                             check_def = 0;
9830                           else
9831                             check_need = 0;
9832                         }
9833
9834                       if (check_need
9835                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9836                         {
9837                           Elf_Internal_Verneed ivn;
9838                           unsigned long offset;
9839
9840                           offset = offset_from_vma
9841                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9842                              sizeof (Elf_External_Verneed));
9843
9844                           do
9845                             {
9846                               Elf_Internal_Vernaux ivna;
9847                               Elf_External_Verneed evn;
9848                               Elf_External_Vernaux evna;
9849                               unsigned long a_off;
9850
9851                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9852                                             _("version need")) == NULL)
9853                                 break;
9854
9855                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9856                               ivn.vn_next = BYTE_GET (evn.vn_next);
9857
9858                               a_off = offset + ivn.vn_aux;
9859
9860                               do
9861                                 {
9862                                   if (get_data (&evna, file, a_off, sizeof (evna),
9863                                                 1, _("version need aux (2)")) == NULL)
9864                                     {
9865                                       ivna.vna_next  = 0;
9866                                       ivna.vna_other = 0;
9867                                     }
9868                                   else
9869                                     {
9870                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9871                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9872                                     }
9873
9874                                   a_off += ivna.vna_next;
9875                                 }
9876                               while (ivna.vna_other != data[cnt + j]
9877                                      && ivna.vna_next != 0);
9878
9879                               if (ivna.vna_other == data[cnt + j])
9880                                 {
9881                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9882
9883                                   if (ivna.vna_name >= string_sec->sh_size)
9884                                     name = _("*invalid*");
9885                                   else
9886                                     name = strtab + ivna.vna_name;
9887                                   nn += printf ("(%s%-*s",
9888                                                 name,
9889                                                 12 - (int) strlen (name),
9890                                                 ")");
9891                                   check_def = 0;
9892                                   break;
9893                                 }
9894
9895                               offset += ivn.vn_next;
9896                             }
9897                           while (ivn.vn_next);
9898                         }
9899
9900                       if (check_def && data[cnt + j] != 0x8001
9901                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9902                         {
9903                           Elf_Internal_Verdef ivd;
9904                           Elf_External_Verdef evd;
9905                           unsigned long offset;
9906
9907                           offset = offset_from_vma
9908                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9909                              sizeof evd);
9910
9911                           do
9912                             {
9913                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9914                                             _("version def")) == NULL)
9915                                 {
9916                                   ivd.vd_next = 0;
9917                                   /* PR 17531: file: 046-1082287-0.004.  */
9918                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9919                                   break;
9920                                 }
9921                               else
9922                                 {
9923                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9924                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9925                                 }
9926
9927                               offset += ivd.vd_next;
9928                             }
9929                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9930                                  && ivd.vd_next != 0);
9931
9932                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9933                             {
9934                               Elf_External_Verdaux evda;
9935                               Elf_Internal_Verdaux ivda;
9936
9937                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9938
9939                               if (get_data (&evda, file,
9940                                             offset - ivd.vd_next + ivd.vd_aux,
9941                                             sizeof (evda), 1,
9942                                             _("version def aux")) == NULL)
9943                                 break;
9944
9945                               ivda.vda_name = BYTE_GET (evda.vda_name);
9946
9947                               if (ivda.vda_name >= string_sec->sh_size)
9948                                 name = _("*invalid*");
9949                               else
9950                                 name = strtab + ivda.vda_name;
9951                               nn += printf ("(%s%-*s",
9952                                             name,
9953                                             12 - (int) strlen (name),
9954                                             ")");
9955                             }
9956                         }
9957
9958                       if (nn < 18)
9959                         printf ("%*c", 18 - nn, ' ');
9960                     }
9961
9962                 putchar ('\n');
9963               }
9964
9965             free (data);
9966             free (strtab);
9967             free (symbols);
9968           }
9969           break;
9970
9971         default:
9972           break;
9973         }
9974     }
9975
9976   if (! found)
9977     printf (_("\nNo version information found in this file.\n"));
9978
9979   return 1;
9980 }
9981
9982 static const char *
9983 get_symbol_binding (unsigned int binding)
9984 {
9985   static char buff[32];
9986
9987   switch (binding)
9988     {
9989     case STB_LOCAL:     return "LOCAL";
9990     case STB_GLOBAL:    return "GLOBAL";
9991     case STB_WEAK:      return "WEAK";
9992     default:
9993       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9994         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9995                   binding);
9996       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9997         {
9998           if (binding == STB_GNU_UNIQUE
9999               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10000                   /* GNU is still using the default value 0.  */
10001                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10002             return "UNIQUE";
10003           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10004         }
10005       else
10006         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10007       return buff;
10008     }
10009 }
10010
10011 static const char *
10012 get_symbol_type (unsigned int type)
10013 {
10014   static char buff[32];
10015
10016   switch (type)
10017     {
10018     case STT_NOTYPE:    return "NOTYPE";
10019     case STT_OBJECT:    return "OBJECT";
10020     case STT_FUNC:      return "FUNC";
10021     case STT_SECTION:   return "SECTION";
10022     case STT_FILE:      return "FILE";
10023     case STT_COMMON:    return "COMMON";
10024     case STT_TLS:       return "TLS";
10025     case STT_RELC:      return "RELC";
10026     case STT_SRELC:     return "SRELC";
10027     default:
10028       if (type >= STT_LOPROC && type <= STT_HIPROC)
10029         {
10030           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10031             return "THUMB_FUNC";
10032
10033           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10034             return "REGISTER";
10035
10036           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10037             return "PARISC_MILLI";
10038
10039           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10040         }
10041       else if (type >= STT_LOOS && type <= STT_HIOS)
10042         {
10043           if (elf_header.e_machine == EM_PARISC)
10044             {
10045               if (type == STT_HP_OPAQUE)
10046                 return "HP_OPAQUE";
10047               if (type == STT_HP_STUB)
10048                 return "HP_STUB";
10049             }
10050
10051           if (type == STT_GNU_IFUNC
10052               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10053                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10054                   /* GNU is still using the default value 0.  */
10055                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10056             return "IFUNC";
10057
10058           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10059         }
10060       else
10061         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10062       return buff;
10063     }
10064 }
10065
10066 static const char *
10067 get_symbol_visibility (unsigned int visibility)
10068 {
10069   switch (visibility)
10070     {
10071     case STV_DEFAULT:   return "DEFAULT";
10072     case STV_INTERNAL:  return "INTERNAL";
10073     case STV_HIDDEN:    return "HIDDEN";
10074     case STV_PROTECTED: return "PROTECTED";
10075     default:
10076       error (_("Unrecognized visibility value: %u"), visibility);
10077       return _("<unknown>");
10078     }
10079 }
10080
10081 static const char *
10082 get_mips_symbol_other (unsigned int other)
10083 {
10084   switch (other)
10085     {
10086     case STO_OPTIONAL:
10087       return "OPTIONAL";
10088     case STO_MIPS_PLT:
10089       return "MIPS PLT";
10090     case STO_MIPS_PIC:
10091       return "MIPS PIC";
10092     case STO_MICROMIPS:
10093       return "MICROMIPS";
10094     case STO_MICROMIPS | STO_MIPS_PIC:
10095       return "MICROMIPS, MIPS PIC";
10096     case STO_MIPS16:
10097       return "MIPS16";
10098     default:
10099       return NULL;
10100     }
10101 }
10102
10103 static const char *
10104 get_ia64_symbol_other (unsigned int other)
10105 {
10106   if (is_ia64_vms ())
10107     {
10108       static char res[32];
10109
10110       res[0] = 0;
10111
10112       /* Function types is for images and .STB files only.  */
10113       switch (elf_header.e_type)
10114         {
10115         case ET_DYN:
10116         case ET_EXEC:
10117           switch (VMS_ST_FUNC_TYPE (other))
10118             {
10119             case VMS_SFT_CODE_ADDR:
10120               strcat (res, " CA");
10121               break;
10122             case VMS_SFT_SYMV_IDX:
10123               strcat (res, " VEC");
10124               break;
10125             case VMS_SFT_FD:
10126               strcat (res, " FD");
10127               break;
10128             case VMS_SFT_RESERVE:
10129               strcat (res, " RSV");
10130               break;
10131             default:
10132               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10133                     VMS_ST_FUNC_TYPE (other));
10134               strcat (res, " <unknown>");
10135               break;
10136             }
10137           break;
10138         default:
10139           break;
10140         }
10141       switch (VMS_ST_LINKAGE (other))
10142         {
10143         case VMS_STL_IGNORE:
10144           strcat (res, " IGN");
10145           break;
10146         case VMS_STL_RESERVE:
10147           strcat (res, " RSV");
10148           break;
10149         case VMS_STL_STD:
10150           strcat (res, " STD");
10151           break;
10152         case VMS_STL_LNK:
10153           strcat (res, " LNK");
10154           break;
10155         default:
10156           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10157                 VMS_ST_LINKAGE (other));
10158           strcat (res, " <unknown>");
10159           break;
10160         }
10161
10162       if (res[0] != 0)
10163         return res + 1;
10164       else
10165         return res;
10166     }
10167   return NULL;
10168 }
10169
10170 static const char *
10171 get_ppc64_symbol_other (unsigned int other)
10172 {
10173   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10174     {
10175       static char buf[32];
10176       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10177                 PPC64_LOCAL_ENTRY_OFFSET (other));
10178       return buf;
10179     }
10180   return NULL;
10181 }
10182
10183 static const char *
10184 get_symbol_other (unsigned int other)
10185 {
10186   const char * result = NULL;
10187   static char buff [32];
10188
10189   if (other == 0)
10190     return "";
10191
10192   switch (elf_header.e_machine)
10193     {
10194     case EM_MIPS:
10195       result = get_mips_symbol_other (other);
10196       break;
10197     case EM_IA_64:
10198       result = get_ia64_symbol_other (other);
10199       break;
10200     case EM_PPC64:
10201       result = get_ppc64_symbol_other (other);
10202       break;
10203     default:
10204       break;
10205     }
10206
10207   if (result)
10208     return result;
10209
10210   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10211   return buff;
10212 }
10213
10214 static const char *
10215 get_symbol_index_type (unsigned int type)
10216 {
10217   static char buff[32];
10218
10219   switch (type)
10220     {
10221     case SHN_UNDEF:     return "UND";
10222     case SHN_ABS:       return "ABS";
10223     case SHN_COMMON:    return "COM";
10224     default:
10225       if (type == SHN_IA_64_ANSI_COMMON
10226           && elf_header.e_machine == EM_IA_64
10227           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10228         return "ANSI_COM";
10229       else if ((elf_header.e_machine == EM_X86_64
10230                 || elf_header.e_machine == EM_L1OM
10231                 || elf_header.e_machine == EM_K1OM)
10232                && type == SHN_X86_64_LCOMMON)
10233         return "LARGE_COM";
10234       else if ((type == SHN_MIPS_SCOMMON
10235                 && elf_header.e_machine == EM_MIPS)
10236                || (type == SHN_TIC6X_SCOMMON
10237                    && elf_header.e_machine == EM_TI_C6000))
10238         return "SCOM";
10239       else if (type == SHN_MIPS_SUNDEFINED
10240                && elf_header.e_machine == EM_MIPS)
10241         return "SUND";
10242       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10243         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10244       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10245         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10246       else if (type >= SHN_LORESERVE)
10247         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10248       else if (type >= elf_header.e_shnum)
10249         sprintf (buff, _("bad section index[%3d]"), type);
10250       else
10251         sprintf (buff, "%3d", type);
10252       break;
10253     }
10254
10255   return buff;
10256 }
10257
10258 static bfd_vma *
10259 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10260 {
10261   unsigned char * e_data;
10262   bfd_vma * i_data;
10263
10264   /* If the size_t type is smaller than the bfd_size_type, eg because
10265      you are building a 32-bit tool on a 64-bit host, then make sure
10266      that when (number) is cast to (size_t) no information is lost.  */
10267   if (sizeof (size_t) < sizeof (bfd_size_type)
10268       && (bfd_size_type) ((size_t) number) != number)
10269     {
10270       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10271              (unsigned long long) number, ent_size);
10272       return NULL;
10273     }
10274
10275   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10276      attempting to allocate memory when the read is bound to fail.  */
10277   if (ent_size * number > current_file_size)
10278     {
10279       error (_("Invalid number of dynamic entries: %llu\n"),
10280              (unsigned long long) number);
10281       return NULL;
10282     }
10283
10284   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10285   if (e_data == NULL)
10286     {
10287       error (_("Out of memory reading %llu dynamic entries\n"),
10288              (unsigned long long) number);
10289       return NULL;
10290     }
10291
10292   if (fread (e_data, ent_size, (size_t) number, file) != number)
10293     {
10294       error (_("Unable to read in %llu bytes of dynamic data\n"),
10295              (unsigned long long) (number * ent_size));
10296       free (e_data);
10297       return NULL;
10298     }
10299
10300   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10301   if (i_data == NULL)
10302     {
10303       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10304              (unsigned long long) number);
10305       free (e_data);
10306       return NULL;
10307     }
10308
10309   while (number--)
10310     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10311
10312   free (e_data);
10313
10314   return i_data;
10315 }
10316
10317 static void
10318 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10319 {
10320   Elf_Internal_Sym * psym;
10321   int n;
10322
10323   n = print_vma (si, DEC_5);
10324   if (n < 5)
10325     fputs (&"     "[n], stdout);
10326   printf (" %3lu: ", hn);
10327
10328   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10329     {
10330       printf (_("<No info available for dynamic symbol number %lu>\n"),
10331               (unsigned long) si);
10332       return;
10333     }
10334
10335   psym = dynamic_symbols + si;
10336   print_vma (psym->st_value, LONG_HEX);
10337   putchar (' ');
10338   print_vma (psym->st_size, DEC_5);
10339
10340   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10341   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10342   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10343   /* Check to see if any other bits in the st_other field are set.
10344      Note - displaying this information disrupts the layout of the
10345      table being generated, but for the moment this case is very
10346      rare.  */
10347   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10348     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10349   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10350   if (VALID_DYNAMIC_NAME (psym->st_name))
10351     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10352   else
10353     printf (_(" <corrupt: %14ld>"), psym->st_name);
10354   putchar ('\n');
10355 }
10356
10357 static const char *
10358 get_symbol_version_string (FILE *file, int is_dynsym,
10359                            const char *strtab,
10360                            unsigned long int strtab_size,
10361                            unsigned int si, Elf_Internal_Sym *psym,
10362                            enum versioned_symbol_info *sym_info,
10363                            unsigned short *vna_other)
10364 {
10365   const char *version_string = NULL;
10366
10367   if (is_dynsym
10368       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10369     {
10370       unsigned char data[2];
10371       unsigned short vers_data;
10372       unsigned long offset;
10373       int is_nobits;
10374       int check_def;
10375
10376       offset = offset_from_vma
10377         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10378          sizeof data + si * sizeof (vers_data));
10379
10380       if (get_data (&data, file, offset + si * sizeof (vers_data),
10381                     sizeof (data), 1, _("version data")) == NULL)
10382         return NULL;
10383
10384       vers_data = byte_get (data, 2);
10385
10386       is_nobits = (section_headers != NULL
10387                    && psym->st_shndx < elf_header.e_shnum
10388                    && section_headers[psym->st_shndx].sh_type
10389                    == SHT_NOBITS);
10390
10391       check_def = (psym->st_shndx != SHN_UNDEF);
10392
10393       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10394         {
10395           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10396               && (is_nobits || ! check_def))
10397             {
10398               Elf_External_Verneed evn;
10399               Elf_Internal_Verneed ivn;
10400               Elf_Internal_Vernaux ivna;
10401
10402               /* We must test both.  */
10403               offset = offset_from_vma
10404                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10405                  sizeof evn);
10406
10407               do
10408                 {
10409                   unsigned long vna_off;
10410
10411                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10412                                 _("version need")) == NULL)
10413                     {
10414                       ivna.vna_next = 0;
10415                       ivna.vna_other = 0;
10416                       ivna.vna_name = 0;
10417                       break;
10418                     }
10419
10420                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10421                   ivn.vn_next = BYTE_GET (evn.vn_next);
10422
10423                   vna_off = offset + ivn.vn_aux;
10424
10425                   do
10426                     {
10427                       Elf_External_Vernaux evna;
10428
10429                       if (get_data (&evna, file, vna_off,
10430                                     sizeof (evna), 1,
10431                                     _("version need aux (3)")) == NULL)
10432                         {
10433                           ivna.vna_next = 0;
10434                           ivna.vna_other = 0;
10435                           ivna.vna_name = 0;
10436                         }
10437                       else
10438                         {
10439                           ivna.vna_other = BYTE_GET (evna.vna_other);
10440                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10441                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10442                         }
10443
10444                       vna_off += ivna.vna_next;
10445                     }
10446                   while (ivna.vna_other != vers_data
10447                          && ivna.vna_next != 0);
10448
10449                   if (ivna.vna_other == vers_data)
10450                     break;
10451
10452                   offset += ivn.vn_next;
10453                 }
10454               while (ivn.vn_next != 0);
10455
10456               if (ivna.vna_other == vers_data)
10457                 {
10458                   *sym_info = symbol_undefined;
10459                   *vna_other = ivna.vna_other;
10460                   version_string = (ivna.vna_name < strtab_size
10461                                     ? strtab + ivna.vna_name
10462                                     : _("<corrupt>"));
10463                   check_def = 0;
10464                 }
10465               else if (! is_nobits)
10466                 error (_("bad dynamic symbol\n"));
10467               else
10468                 check_def = 1;
10469             }
10470
10471           if (check_def)
10472             {
10473               if (vers_data != 0x8001
10474                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10475                 {
10476                   Elf_Internal_Verdef ivd;
10477                   Elf_Internal_Verdaux ivda;
10478                   Elf_External_Verdaux evda;
10479                   unsigned long off;
10480
10481                   off = offset_from_vma
10482                     (file,
10483                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10484                      sizeof (Elf_External_Verdef));
10485
10486                   do
10487                     {
10488                       Elf_External_Verdef evd;
10489
10490                       if (get_data (&evd, file, off, sizeof (evd),
10491                                     1, _("version def")) == NULL)
10492                         {
10493                           ivd.vd_ndx = 0;
10494                           ivd.vd_aux = 0;
10495                           ivd.vd_next = 0;
10496                         }
10497                       else
10498                         {
10499                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10500                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10501                           ivd.vd_next = BYTE_GET (evd.vd_next);
10502                         }
10503
10504                       off += ivd.vd_next;
10505                     }
10506                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10507                          && ivd.vd_next != 0);
10508
10509                   off -= ivd.vd_next;
10510                   off += ivd.vd_aux;
10511
10512                   if (get_data (&evda, file, off, sizeof (evda),
10513                                 1, _("version def aux")) == NULL)
10514                     return version_string;
10515
10516                   ivda.vda_name = BYTE_GET (evda.vda_name);
10517
10518                   if (psym->st_name != ivda.vda_name)
10519                     {
10520                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10521                                    ? symbol_hidden : symbol_public);
10522                       version_string = (ivda.vda_name < strtab_size
10523                                         ? strtab + ivda.vda_name
10524                                         : _("<corrupt>"));
10525                     }
10526                 }
10527             }
10528         }
10529     }
10530   return version_string;
10531 }
10532
10533 /* Dump the symbol table.  */
10534 static int
10535 process_symbol_table (FILE * file)
10536 {
10537   Elf_Internal_Shdr * section;
10538   bfd_size_type nbuckets = 0;
10539   bfd_size_type nchains = 0;
10540   bfd_vma * buckets = NULL;
10541   bfd_vma * chains = NULL;
10542   bfd_vma ngnubuckets = 0;
10543   bfd_vma * gnubuckets = NULL;
10544   bfd_vma * gnuchains = NULL;
10545   bfd_vma gnusymidx = 0;
10546   bfd_size_type ngnuchains = 0;
10547
10548   if (!do_syms && !do_dyn_syms && !do_histogram)
10549     return 1;
10550
10551   if (dynamic_info[DT_HASH]
10552       && (do_histogram
10553           || (do_using_dynamic
10554               && !do_dyn_syms
10555               && dynamic_strings != NULL)))
10556     {
10557       unsigned char nb[8];
10558       unsigned char nc[8];
10559       unsigned int hash_ent_size = 4;
10560
10561       if ((elf_header.e_machine == EM_ALPHA
10562            || elf_header.e_machine == EM_S390
10563            || elf_header.e_machine == EM_S390_OLD)
10564           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10565         hash_ent_size = 8;
10566
10567       if (fseek (file,
10568                  (archive_file_offset
10569                   + offset_from_vma (file, dynamic_info[DT_HASH],
10570                                      sizeof nb + sizeof nc)),
10571                  SEEK_SET))
10572         {
10573           error (_("Unable to seek to start of dynamic information\n"));
10574           goto no_hash;
10575         }
10576
10577       if (fread (nb, hash_ent_size, 1, file) != 1)
10578         {
10579           error (_("Failed to read in number of buckets\n"));
10580           goto no_hash;
10581         }
10582
10583       if (fread (nc, hash_ent_size, 1, file) != 1)
10584         {
10585           error (_("Failed to read in number of chains\n"));
10586           goto no_hash;
10587         }
10588
10589       nbuckets = byte_get (nb, hash_ent_size);
10590       nchains  = byte_get (nc, hash_ent_size);
10591
10592       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10593       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10594
10595     no_hash:
10596       if (buckets == NULL || chains == NULL)
10597         {
10598           if (do_using_dynamic)
10599             return 0;
10600           free (buckets);
10601           free (chains);
10602           buckets = NULL;
10603           chains = NULL;
10604           nbuckets = 0;
10605           nchains = 0;
10606         }
10607     }
10608
10609   if (dynamic_info_DT_GNU_HASH
10610       && (do_histogram
10611           || (do_using_dynamic
10612               && !do_dyn_syms
10613               && dynamic_strings != NULL)))
10614     {
10615       unsigned char nb[16];
10616       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10617       bfd_vma buckets_vma;
10618
10619       if (fseek (file,
10620                  (archive_file_offset
10621                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10622                                      sizeof nb)),
10623                  SEEK_SET))
10624         {
10625           error (_("Unable to seek to start of dynamic information\n"));
10626           goto no_gnu_hash;
10627         }
10628
10629       if (fread (nb, 16, 1, file) != 1)
10630         {
10631           error (_("Failed to read in number of buckets\n"));
10632           goto no_gnu_hash;
10633         }
10634
10635       ngnubuckets = byte_get (nb, 4);
10636       gnusymidx = byte_get (nb + 4, 4);
10637       bitmaskwords = byte_get (nb + 8, 4);
10638       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10639       if (is_32bit_elf)
10640         buckets_vma += bitmaskwords * 4;
10641       else
10642         buckets_vma += bitmaskwords * 8;
10643
10644       if (fseek (file,
10645                  (archive_file_offset
10646                   + offset_from_vma (file, buckets_vma, 4)),
10647                  SEEK_SET))
10648         {
10649           error (_("Unable to seek to start of dynamic information\n"));
10650           goto no_gnu_hash;
10651         }
10652
10653       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10654
10655       if (gnubuckets == NULL)
10656         goto no_gnu_hash;
10657
10658       for (i = 0; i < ngnubuckets; i++)
10659         if (gnubuckets[i] != 0)
10660           {
10661             if (gnubuckets[i] < gnusymidx)
10662               return 0;
10663
10664             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10665               maxchain = gnubuckets[i];
10666           }
10667
10668       if (maxchain == 0xffffffff)
10669         goto no_gnu_hash;
10670
10671       maxchain -= gnusymidx;
10672
10673       if (fseek (file,
10674                  (archive_file_offset
10675                   + offset_from_vma (file, buckets_vma
10676                                            + 4 * (ngnubuckets + maxchain), 4)),
10677                  SEEK_SET))
10678         {
10679           error (_("Unable to seek to start of dynamic information\n"));
10680           goto no_gnu_hash;
10681         }
10682
10683       do
10684         {
10685           if (fread (nb, 4, 1, file) != 1)
10686             {
10687               error (_("Failed to determine last chain length\n"));
10688               goto no_gnu_hash;
10689             }
10690
10691           if (maxchain + 1 == 0)
10692             goto no_gnu_hash;
10693
10694           ++maxchain;
10695         }
10696       while ((byte_get (nb, 4) & 1) == 0);
10697
10698       if (fseek (file,
10699                  (archive_file_offset
10700                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10701                  SEEK_SET))
10702         {
10703           error (_("Unable to seek to start of dynamic information\n"));
10704           goto no_gnu_hash;
10705         }
10706
10707       gnuchains = get_dynamic_data (file, maxchain, 4);
10708       ngnuchains = maxchain;
10709
10710     no_gnu_hash:
10711       if (gnuchains == NULL)
10712         {
10713           free (gnubuckets);
10714           gnubuckets = NULL;
10715           ngnubuckets = 0;
10716           if (do_using_dynamic)
10717             return 0;
10718         }
10719     }
10720
10721   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10722       && do_syms
10723       && do_using_dynamic
10724       && dynamic_strings != NULL
10725       && dynamic_symbols != NULL)
10726     {
10727       unsigned long hn;
10728
10729       if (dynamic_info[DT_HASH])
10730         {
10731           bfd_vma si;
10732
10733           printf (_("\nSymbol table for image:\n"));
10734           if (is_32bit_elf)
10735             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10736           else
10737             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10738
10739           for (hn = 0; hn < nbuckets; hn++)
10740             {
10741               if (! buckets[hn])
10742                 continue;
10743
10744               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10745                 print_dynamic_symbol (si, hn);
10746             }
10747         }
10748
10749       if (dynamic_info_DT_GNU_HASH)
10750         {
10751           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10752           if (is_32bit_elf)
10753             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10754           else
10755             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10756
10757           for (hn = 0; hn < ngnubuckets; ++hn)
10758             if (gnubuckets[hn] != 0)
10759               {
10760                 bfd_vma si = gnubuckets[hn];
10761                 bfd_vma off = si - gnusymidx;
10762
10763                 do
10764                   {
10765                     print_dynamic_symbol (si, hn);
10766                     si++;
10767                   }
10768                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10769               }
10770         }
10771     }
10772   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10773            && section_headers != NULL)
10774     {
10775       unsigned int i;
10776
10777       for (i = 0, section = section_headers;
10778            i < elf_header.e_shnum;
10779            i++, section++)
10780         {
10781           unsigned int si;
10782           char * strtab = NULL;
10783           unsigned long int strtab_size = 0;
10784           Elf_Internal_Sym * symtab;
10785           Elf_Internal_Sym * psym;
10786           unsigned long num_syms;
10787
10788           if ((section->sh_type != SHT_SYMTAB
10789                && section->sh_type != SHT_DYNSYM)
10790               || (!do_syms
10791                   && section->sh_type == SHT_SYMTAB))
10792             continue;
10793
10794           if (section->sh_entsize == 0)
10795             {
10796               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10797                       printable_section_name (section));
10798               continue;
10799             }
10800
10801           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10802                   printable_section_name (section),
10803                   (unsigned long) (section->sh_size / section->sh_entsize));
10804
10805           if (is_32bit_elf)
10806             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10807           else
10808             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10809
10810           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10811           if (symtab == NULL)
10812             continue;
10813
10814           if (section->sh_link == elf_header.e_shstrndx)
10815             {
10816               strtab = string_table;
10817               strtab_size = string_table_length;
10818             }
10819           else if (section->sh_link < elf_header.e_shnum)
10820             {
10821               Elf_Internal_Shdr * string_sec;
10822
10823               string_sec = section_headers + section->sh_link;
10824
10825               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10826                                           1, string_sec->sh_size,
10827                                           _("string table"));
10828               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10829             }
10830
10831           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10832             {
10833               const char *version_string;
10834               enum versioned_symbol_info sym_info;
10835               unsigned short vna_other;
10836
10837               printf ("%6d: ", si);
10838               print_vma (psym->st_value, LONG_HEX);
10839               putchar (' ');
10840               print_vma (psym->st_size, DEC_5);
10841               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10842               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10843               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10844               /* Check to see if any other bits in the st_other field are set.
10845                  Note - displaying this information disrupts the layout of the
10846                  table being generated, but for the moment this case is very rare.  */
10847               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10848                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10849               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10850               print_symbol (25, psym->st_name < strtab_size
10851                             ? strtab + psym->st_name : _("<corrupt>"));
10852
10853               version_string
10854                 = get_symbol_version_string (file,
10855                                              section->sh_type == SHT_DYNSYM,
10856                                              strtab, strtab_size, si,
10857                                              psym, &sym_info, &vna_other);
10858               if (version_string)
10859                 {
10860                   if (sym_info == symbol_undefined)
10861                     printf ("@%s (%d)", version_string, vna_other);
10862                   else
10863                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10864                             version_string);
10865                 }
10866
10867               putchar ('\n');
10868             }
10869
10870           free (symtab);
10871           if (strtab != string_table)
10872             free (strtab);
10873         }
10874     }
10875   else if (do_syms)
10876     printf
10877       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10878
10879   if (do_histogram && buckets != NULL)
10880     {
10881       unsigned long * lengths;
10882       unsigned long * counts;
10883       unsigned long hn;
10884       bfd_vma si;
10885       unsigned long maxlength = 0;
10886       unsigned long nzero_counts = 0;
10887       unsigned long nsyms = 0;
10888       unsigned long chained;
10889
10890       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10891               (unsigned long) nbuckets);
10892
10893       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10894       if (lengths == NULL)
10895         {
10896           error (_("Out of memory allocating space for histogram buckets\n"));
10897           return 0;
10898         }
10899
10900       printf (_(" Length  Number     %% of total  Coverage\n"));
10901       for (hn = 0; hn < nbuckets; ++hn)
10902         {
10903           for (si = buckets[hn], chained = 0;
10904                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10905                si = chains[si], ++chained)
10906             {
10907               ++nsyms;
10908               if (maxlength < ++lengths[hn])
10909                 ++maxlength;
10910             }
10911
10912             /* PR binutils/17531: A corrupt binary could contain broken
10913                histogram data.  Do not go into an infinite loop trying
10914                to process it.  */
10915             if (chained > nchains)
10916               {
10917                 error (_("histogram chain is corrupt\n"));
10918                 break;
10919               }
10920         }
10921
10922       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10923       if (counts == NULL)
10924         {
10925           free (lengths);
10926           error (_("Out of memory allocating space for histogram counts\n"));
10927           return 0;
10928         }
10929
10930       for (hn = 0; hn < nbuckets; ++hn)
10931         ++counts[lengths[hn]];
10932
10933       if (nbuckets > 0)
10934         {
10935           unsigned long i;
10936           printf ("      0  %-10lu (%5.1f%%)\n",
10937                   counts[0], (counts[0] * 100.0) / nbuckets);
10938           for (i = 1; i <= maxlength; ++i)
10939             {
10940               nzero_counts += counts[i] * i;
10941               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10942                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10943                       (nzero_counts * 100.0) / nsyms);
10944             }
10945         }
10946
10947       free (counts);
10948       free (lengths);
10949     }
10950
10951   if (buckets != NULL)
10952     {
10953       free (buckets);
10954       free (chains);
10955     }
10956
10957   if (do_histogram && gnubuckets != NULL)
10958     {
10959       unsigned long * lengths;
10960       unsigned long * counts;
10961       unsigned long hn;
10962       unsigned long maxlength = 0;
10963       unsigned long nzero_counts = 0;
10964       unsigned long nsyms = 0;
10965
10966       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10967               (unsigned long) ngnubuckets);
10968
10969       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10970       if (lengths == NULL)
10971         {
10972           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10973           return 0;
10974         }
10975
10976       printf (_(" Length  Number     %% of total  Coverage\n"));
10977
10978       for (hn = 0; hn < ngnubuckets; ++hn)
10979         if (gnubuckets[hn] != 0)
10980           {
10981             bfd_vma off, length = 1;
10982
10983             for (off = gnubuckets[hn] - gnusymidx;
10984                  /* PR 17531 file: 010-77222-0.004.  */
10985                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10986                  ++off)
10987               ++length;
10988             lengths[hn] = length;
10989             if (length > maxlength)
10990               maxlength = length;
10991             nsyms += length;
10992           }
10993
10994       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10995       if (counts == NULL)
10996         {
10997           free (lengths);
10998           error (_("Out of memory allocating space for gnu histogram counts\n"));
10999           return 0;
11000         }
11001
11002       for (hn = 0; hn < ngnubuckets; ++hn)
11003         ++counts[lengths[hn]];
11004
11005       if (ngnubuckets > 0)
11006         {
11007           unsigned long j;
11008           printf ("      0  %-10lu (%5.1f%%)\n",
11009                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11010           for (j = 1; j <= maxlength; ++j)
11011             {
11012               nzero_counts += counts[j] * j;
11013               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11014                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11015                       (nzero_counts * 100.0) / nsyms);
11016             }
11017         }
11018
11019       free (counts);
11020       free (lengths);
11021       free (gnubuckets);
11022       free (gnuchains);
11023     }
11024
11025   return 1;
11026 }
11027
11028 static int
11029 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11030 {
11031   unsigned int i;
11032
11033   if (dynamic_syminfo == NULL
11034       || !do_dynamic)
11035     /* No syminfo, this is ok.  */
11036     return 1;
11037
11038   /* There better should be a dynamic symbol section.  */
11039   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11040     return 0;
11041
11042   if (dynamic_addr)
11043     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11044             dynamic_syminfo_offset, dynamic_syminfo_nent);
11045
11046   printf (_(" Num: Name                           BoundTo     Flags\n"));
11047   for (i = 0; i < dynamic_syminfo_nent; ++i)
11048     {
11049       unsigned short int flags = dynamic_syminfo[i].si_flags;
11050
11051       printf ("%4d: ", i);
11052       if (i >= num_dynamic_syms)
11053         printf (_("<corrupt index>"));
11054       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11055         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11056       else
11057         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11058       putchar (' ');
11059
11060       switch (dynamic_syminfo[i].si_boundto)
11061         {
11062         case SYMINFO_BT_SELF:
11063           fputs ("SELF       ", stdout);
11064           break;
11065         case SYMINFO_BT_PARENT:
11066           fputs ("PARENT     ", stdout);
11067           break;
11068         default:
11069           if (dynamic_syminfo[i].si_boundto > 0
11070               && dynamic_syminfo[i].si_boundto < dynamic_nent
11071               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11072             {
11073               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11074               putchar (' ' );
11075             }
11076           else
11077             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11078           break;
11079         }
11080
11081       if (flags & SYMINFO_FLG_DIRECT)
11082         printf (" DIRECT");
11083       if (flags & SYMINFO_FLG_PASSTHRU)
11084         printf (" PASSTHRU");
11085       if (flags & SYMINFO_FLG_COPY)
11086         printf (" COPY");
11087       if (flags & SYMINFO_FLG_LAZYLOAD)
11088         printf (" LAZYLOAD");
11089
11090       puts ("");
11091     }
11092
11093   return 1;
11094 }
11095
11096 /* Check to see if the given reloc needs to be handled in a target specific
11097    manner.  If so then process the reloc and return TRUE otherwise return
11098    FALSE.  */
11099
11100 static bfd_boolean
11101 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11102                                 unsigned char *     start,
11103                                 Elf_Internal_Sym *  symtab)
11104 {
11105   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11106
11107   switch (elf_header.e_machine)
11108     {
11109     case EM_MSP430:
11110     case EM_MSP430_OLD:
11111       {
11112         static Elf_Internal_Sym * saved_sym = NULL;
11113
11114         switch (reloc_type)
11115           {
11116           case 10: /* R_MSP430_SYM_DIFF */
11117             if (uses_msp430x_relocs ())
11118               break;
11119           case 21: /* R_MSP430X_SYM_DIFF */
11120             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11121             return TRUE;
11122
11123           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11124           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11125             goto handle_sym_diff;
11126
11127           case 5: /* R_MSP430_16_BYTE */
11128           case 9: /* R_MSP430_8 */
11129             if (uses_msp430x_relocs ())
11130               break;
11131             goto handle_sym_diff;
11132
11133           case 2: /* R_MSP430_ABS16 */
11134           case 15: /* R_MSP430X_ABS16 */
11135             if (! uses_msp430x_relocs ())
11136               break;
11137             goto handle_sym_diff;
11138
11139           handle_sym_diff:
11140             if (saved_sym != NULL)
11141               {
11142                 bfd_vma value;
11143
11144                 value = reloc->r_addend
11145                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11146                      - saved_sym->st_value);
11147
11148                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11149
11150                 saved_sym = NULL;
11151                 return TRUE;
11152               }
11153             break;
11154
11155           default:
11156             if (saved_sym != NULL)
11157               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11158             break;
11159           }
11160         break;
11161       }
11162
11163     case EM_MN10300:
11164     case EM_CYGNUS_MN10300:
11165       {
11166         static Elf_Internal_Sym * saved_sym = NULL;
11167
11168         switch (reloc_type)
11169           {
11170           case 34: /* R_MN10300_ALIGN */
11171             return TRUE;
11172           case 33: /* R_MN10300_SYM_DIFF */
11173             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11174             return TRUE;
11175           case 1: /* R_MN10300_32 */
11176           case 2: /* R_MN10300_16 */
11177             if (saved_sym != NULL)
11178               {
11179                 bfd_vma value;
11180
11181                 value = reloc->r_addend
11182                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11183                      - saved_sym->st_value);
11184
11185                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11186
11187                 saved_sym = NULL;
11188                 return TRUE;
11189               }
11190             break;
11191           default:
11192             if (saved_sym != NULL)
11193               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11194             break;
11195           }
11196         break;
11197       }
11198
11199     case EM_RL78:
11200       {
11201         static bfd_vma saved_sym1 = 0;
11202         static bfd_vma saved_sym2 = 0;
11203         static bfd_vma value;
11204
11205         switch (reloc_type)
11206           {
11207           case 0x80: /* R_RL78_SYM.  */
11208             saved_sym1 = saved_sym2;
11209             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11210             saved_sym2 += reloc->r_addend;
11211             return TRUE;
11212
11213           case 0x83: /* R_RL78_OPsub.  */
11214             value = saved_sym1 - saved_sym2;
11215             saved_sym2 = saved_sym1 = 0;
11216             return TRUE;
11217             break;
11218
11219           case 0x41: /* R_RL78_ABS32.  */
11220             byte_put (start + reloc->r_offset, value, 4);
11221             value = 0;
11222             return TRUE;
11223
11224           case 0x43: /* R_RL78_ABS16.  */
11225             byte_put (start + reloc->r_offset, value, 2);
11226             value = 0;
11227             return TRUE;
11228
11229           default:
11230             break;
11231           }
11232         break;
11233       }
11234     }
11235
11236   return FALSE;
11237 }
11238
11239 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11240    DWARF debug sections.  This is a target specific test.  Note - we do not
11241    go through the whole including-target-headers-multiple-times route, (as
11242    we have already done with <elf/h8.h>) because this would become very
11243    messy and even then this function would have to contain target specific
11244    information (the names of the relocs instead of their numeric values).
11245    FIXME: This is not the correct way to solve this problem.  The proper way
11246    is to have target specific reloc sizing and typing functions created by
11247    the reloc-macros.h header, in the same way that it already creates the
11248    reloc naming functions.  */
11249
11250 static bfd_boolean
11251 is_32bit_abs_reloc (unsigned int reloc_type)
11252 {
11253   switch (elf_header.e_machine)
11254     {
11255     case EM_386:
11256     case EM_IAMCU:
11257       return reloc_type == 1; /* R_386_32.  */
11258     case EM_68K:
11259       return reloc_type == 1; /* R_68K_32.  */
11260     case EM_860:
11261       return reloc_type == 1; /* R_860_32.  */
11262     case EM_960:
11263       return reloc_type == 2; /* R_960_32.  */
11264     case EM_AARCH64:
11265       return reloc_type == 258; /* R_AARCH64_ABS32 */
11266     case EM_ALPHA:
11267       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11268     case EM_ARC:
11269       return reloc_type == 1; /* R_ARC_32.  */
11270     case EM_ARM:
11271       return reloc_type == 2; /* R_ARM_ABS32 */
11272     case EM_AVR_OLD:
11273     case EM_AVR:
11274       return reloc_type == 1;
11275     case EM_ADAPTEVA_EPIPHANY:
11276       return reloc_type == 3;
11277     case EM_BLACKFIN:
11278       return reloc_type == 0x12; /* R_byte4_data.  */
11279     case EM_CRIS:
11280       return reloc_type == 3; /* R_CRIS_32.  */
11281     case EM_CR16:
11282       return reloc_type == 3; /* R_CR16_NUM32.  */
11283     case EM_CRX:
11284       return reloc_type == 15; /* R_CRX_NUM32.  */
11285     case EM_CYGNUS_FRV:
11286       return reloc_type == 1;
11287     case EM_CYGNUS_D10V:
11288     case EM_D10V:
11289       return reloc_type == 6; /* R_D10V_32.  */
11290     case EM_CYGNUS_D30V:
11291     case EM_D30V:
11292       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11293     case EM_DLX:
11294       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11295     case EM_CYGNUS_FR30:
11296     case EM_FR30:
11297       return reloc_type == 3; /* R_FR30_32.  */
11298     case EM_FT32:
11299       return reloc_type == 1; /* R_FT32_32.  */
11300     case EM_H8S:
11301     case EM_H8_300:
11302     case EM_H8_300H:
11303       return reloc_type == 1; /* R_H8_DIR32.  */
11304     case EM_IA_64:
11305       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11306         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11307     case EM_IP2K_OLD:
11308     case EM_IP2K:
11309       return reloc_type == 2; /* R_IP2K_32.  */
11310     case EM_IQ2000:
11311       return reloc_type == 2; /* R_IQ2000_32.  */
11312     case EM_LATTICEMICO32:
11313       return reloc_type == 3; /* R_LM32_32.  */
11314     case EM_M32C_OLD:
11315     case EM_M32C:
11316       return reloc_type == 3; /* R_M32C_32.  */
11317     case EM_M32R:
11318       return reloc_type == 34; /* R_M32R_32_RELA.  */
11319     case EM_MCORE:
11320       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11321     case EM_CYGNUS_MEP:
11322       return reloc_type == 4; /* R_MEP_32.  */
11323     case EM_METAG:
11324       return reloc_type == 2; /* R_METAG_ADDR32.  */
11325     case EM_MICROBLAZE:
11326       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11327     case EM_MIPS:
11328       return reloc_type == 2; /* R_MIPS_32.  */
11329     case EM_MMIX:
11330       return reloc_type == 4; /* R_MMIX_32.  */
11331     case EM_CYGNUS_MN10200:
11332     case EM_MN10200:
11333       return reloc_type == 1; /* R_MN10200_32.  */
11334     case EM_CYGNUS_MN10300:
11335     case EM_MN10300:
11336       return reloc_type == 1; /* R_MN10300_32.  */
11337     case EM_MOXIE:
11338       return reloc_type == 1; /* R_MOXIE_32.  */
11339     case EM_MSP430_OLD:
11340     case EM_MSP430:
11341       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11342     case EM_MT:
11343       return reloc_type == 2; /* R_MT_32.  */
11344     case EM_NDS32:
11345       return reloc_type == 20; /* R_NDS32_RELA.  */
11346     case EM_ALTERA_NIOS2:
11347       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11348     case EM_NIOS32:
11349       return reloc_type == 1; /* R_NIOS_32.  */
11350     case EM_OR1K:
11351       return reloc_type == 1; /* R_OR1K_32.  */
11352     case EM_PARISC:
11353       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11354               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11355     case EM_PJ:
11356     case EM_PJ_OLD:
11357       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11358     case EM_PPC64:
11359       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11360     case EM_PPC:
11361       return reloc_type == 1; /* R_PPC_ADDR32.  */
11362     case EM_RL78:
11363       return reloc_type == 1; /* R_RL78_DIR32.  */
11364     case EM_RX:
11365       return reloc_type == 1; /* R_RX_DIR32.  */
11366     case EM_S370:
11367       return reloc_type == 1; /* R_I370_ADDR31.  */
11368     case EM_S390_OLD:
11369     case EM_S390:
11370       return reloc_type == 4; /* R_S390_32.  */
11371     case EM_SCORE:
11372       return reloc_type == 8; /* R_SCORE_ABS32.  */
11373     case EM_SH:
11374       return reloc_type == 1; /* R_SH_DIR32.  */
11375     case EM_SPARC32PLUS:
11376     case EM_SPARCV9:
11377     case EM_SPARC:
11378       return reloc_type == 3 /* R_SPARC_32.  */
11379         || reloc_type == 23; /* R_SPARC_UA32.  */
11380     case EM_SPU:
11381       return reloc_type == 6; /* R_SPU_ADDR32 */
11382     case EM_TI_C6000:
11383       return reloc_type == 1; /* R_C6000_ABS32.  */
11384     case EM_TILEGX:
11385       return reloc_type == 2; /* R_TILEGX_32.  */
11386     case EM_TILEPRO:
11387       return reloc_type == 1; /* R_TILEPRO_32.  */
11388     case EM_CYGNUS_V850:
11389     case EM_V850:
11390       return reloc_type == 6; /* R_V850_ABS32.  */
11391     case EM_V800:
11392       return reloc_type == 0x33; /* R_V810_WORD.  */
11393     case EM_VAX:
11394       return reloc_type == 1; /* R_VAX_32.  */
11395     case EM_VISIUM:
11396       return reloc_type == 3;  /* R_VISIUM_32. */
11397     case EM_X86_64:
11398     case EM_L1OM:
11399     case EM_K1OM:
11400       return reloc_type == 10; /* R_X86_64_32.  */
11401     case EM_XC16X:
11402     case EM_C166:
11403       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11404     case EM_XGATE:
11405       return reloc_type == 4; /* R_XGATE_32.  */
11406     case EM_XSTORMY16:
11407       return reloc_type == 1; /* R_XSTROMY16_32.  */
11408     case EM_XTENSA_OLD:
11409     case EM_XTENSA:
11410       return reloc_type == 1; /* R_XTENSA_32.  */
11411     default:
11412       {
11413         static unsigned int prev_warn = 0;
11414
11415         /* Avoid repeating the same warning multiple times.  */
11416         if (prev_warn != elf_header.e_machine)
11417           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11418                  elf_header.e_machine);
11419         prev_warn = elf_header.e_machine;
11420         return FALSE;
11421       }
11422     }
11423 }
11424
11425 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11426    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11427
11428 static bfd_boolean
11429 is_32bit_pcrel_reloc (unsigned int reloc_type)
11430 {
11431   switch (elf_header.e_machine)
11432     {
11433     case EM_386:
11434     case EM_IAMCU:
11435       return reloc_type == 2;  /* R_386_PC32.  */
11436     case EM_68K:
11437       return reloc_type == 4;  /* R_68K_PC32.  */
11438     case EM_AARCH64:
11439       return reloc_type == 261; /* R_AARCH64_PREL32 */
11440     case EM_ADAPTEVA_EPIPHANY:
11441       return reloc_type == 6;
11442     case EM_ALPHA:
11443       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11444     case EM_ARM:
11445       return reloc_type == 3;  /* R_ARM_REL32 */
11446     case EM_MICROBLAZE:
11447       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11448     case EM_OR1K:
11449       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11450     case EM_PARISC:
11451       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11452     case EM_PPC:
11453       return reloc_type == 26; /* R_PPC_REL32.  */
11454     case EM_PPC64:
11455       return reloc_type == 26; /* R_PPC64_REL32.  */
11456     case EM_S390_OLD:
11457     case EM_S390:
11458       return reloc_type == 5;  /* R_390_PC32.  */
11459     case EM_SH:
11460       return reloc_type == 2;  /* R_SH_REL32.  */
11461     case EM_SPARC32PLUS:
11462     case EM_SPARCV9:
11463     case EM_SPARC:
11464       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11465     case EM_SPU:
11466       return reloc_type == 13; /* R_SPU_REL32.  */
11467     case EM_TILEGX:
11468       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11469     case EM_TILEPRO:
11470       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11471     case EM_VISIUM:
11472       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11473     case EM_X86_64:
11474     case EM_L1OM:
11475     case EM_K1OM:
11476       return reloc_type == 2;  /* R_X86_64_PC32.  */
11477     case EM_XTENSA_OLD:
11478     case EM_XTENSA:
11479       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11480     default:
11481       /* Do not abort or issue an error message here.  Not all targets use
11482          pc-relative 32-bit relocs in their DWARF debug information and we
11483          have already tested for target coverage in is_32bit_abs_reloc.  A
11484          more helpful warning message will be generated by apply_relocations
11485          anyway, so just return.  */
11486       return FALSE;
11487     }
11488 }
11489
11490 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11491    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11492
11493 static bfd_boolean
11494 is_64bit_abs_reloc (unsigned int reloc_type)
11495 {
11496   switch (elf_header.e_machine)
11497     {
11498     case EM_AARCH64:
11499       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11500     case EM_ALPHA:
11501       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11502     case EM_IA_64:
11503       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11504     case EM_PARISC:
11505       return reloc_type == 80; /* R_PARISC_DIR64.  */
11506     case EM_PPC64:
11507       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11508     case EM_SPARC32PLUS:
11509     case EM_SPARCV9:
11510     case EM_SPARC:
11511       return reloc_type == 54; /* R_SPARC_UA64.  */
11512     case EM_X86_64:
11513     case EM_L1OM:
11514     case EM_K1OM:
11515       return reloc_type == 1; /* R_X86_64_64.  */
11516     case EM_S390_OLD:
11517     case EM_S390:
11518       return reloc_type == 22;  /* R_S390_64.  */
11519     case EM_TILEGX:
11520       return reloc_type == 1; /* R_TILEGX_64.  */
11521     case EM_MIPS:
11522       return reloc_type == 18;  /* R_MIPS_64.  */
11523     default:
11524       return FALSE;
11525     }
11526 }
11527
11528 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11529    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11530
11531 static bfd_boolean
11532 is_64bit_pcrel_reloc (unsigned int reloc_type)
11533 {
11534   switch (elf_header.e_machine)
11535     {
11536     case EM_AARCH64:
11537       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11538     case EM_ALPHA:
11539       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11540     case EM_IA_64:
11541       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11542     case EM_PARISC:
11543       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11544     case EM_PPC64:
11545       return reloc_type == 44; /* R_PPC64_REL64.  */
11546     case EM_SPARC32PLUS:
11547     case EM_SPARCV9:
11548     case EM_SPARC:
11549       return reloc_type == 46; /* R_SPARC_DISP64.  */
11550     case EM_X86_64:
11551     case EM_L1OM:
11552     case EM_K1OM:
11553       return reloc_type == 24; /* R_X86_64_PC64.  */
11554     case EM_S390_OLD:
11555     case EM_S390:
11556       return reloc_type == 23;  /* R_S390_PC64.  */
11557     case EM_TILEGX:
11558       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11559     default:
11560       return FALSE;
11561     }
11562 }
11563
11564 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11565    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11566
11567 static bfd_boolean
11568 is_24bit_abs_reloc (unsigned int reloc_type)
11569 {
11570   switch (elf_header.e_machine)
11571     {
11572     case EM_CYGNUS_MN10200:
11573     case EM_MN10200:
11574       return reloc_type == 4; /* R_MN10200_24.  */
11575     default:
11576       return FALSE;
11577     }
11578 }
11579
11580 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11581    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11582
11583 static bfd_boolean
11584 is_16bit_abs_reloc (unsigned int reloc_type)
11585 {
11586   switch (elf_header.e_machine)
11587     {
11588     case EM_AVR_OLD:
11589     case EM_AVR:
11590       return reloc_type == 4; /* R_AVR_16.  */
11591     case EM_ADAPTEVA_EPIPHANY:
11592       return reloc_type == 5;
11593     case EM_CYGNUS_D10V:
11594     case EM_D10V:
11595       return reloc_type == 3; /* R_D10V_16.  */
11596     case EM_H8S:
11597     case EM_H8_300:
11598     case EM_H8_300H:
11599       return reloc_type == R_H8_DIR16;
11600     case EM_IP2K_OLD:
11601     case EM_IP2K:
11602       return reloc_type == 1; /* R_IP2K_16.  */
11603     case EM_M32C_OLD:
11604     case EM_M32C:
11605       return reloc_type == 1; /* R_M32C_16 */
11606     case EM_MSP430:
11607       if (uses_msp430x_relocs ())
11608         return reloc_type == 2; /* R_MSP430_ABS16.  */
11609     case EM_MSP430_OLD:
11610       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11611     case EM_NDS32:
11612       return reloc_type == 19; /* R_NDS32_RELA.  */
11613     case EM_ALTERA_NIOS2:
11614       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11615     case EM_NIOS32:
11616       return reloc_type == 9; /* R_NIOS_16.  */
11617     case EM_OR1K:
11618       return reloc_type == 2; /* R_OR1K_16.  */
11619     case EM_TI_C6000:
11620       return reloc_type == 2; /* R_C6000_ABS16.  */
11621     case EM_XC16X:
11622     case EM_C166:
11623       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11624     case EM_CYGNUS_MN10200:
11625     case EM_MN10200:
11626       return reloc_type == 2; /* R_MN10200_16.  */
11627     case EM_CYGNUS_MN10300:
11628     case EM_MN10300:
11629       return reloc_type == 2; /* R_MN10300_16.  */
11630     case EM_VISIUM:
11631       return reloc_type == 2; /* R_VISIUM_16. */
11632     case EM_XGATE:
11633       return reloc_type == 3; /* R_XGATE_16.  */
11634     default:
11635       return FALSE;
11636     }
11637 }
11638
11639 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11640    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11641
11642 static bfd_boolean
11643 is_none_reloc (unsigned int reloc_type)
11644 {
11645   switch (elf_header.e_machine)
11646     {
11647     case EM_68K:     /* R_68K_NONE.  */
11648     case EM_386:     /* R_386_NONE.  */
11649     case EM_SPARC32PLUS:
11650     case EM_SPARCV9:
11651     case EM_SPARC:   /* R_SPARC_NONE.  */
11652     case EM_MIPS:    /* R_MIPS_NONE.  */
11653     case EM_PARISC:  /* R_PARISC_NONE.  */
11654     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11655     case EM_ADAPTEVA_EPIPHANY:
11656     case EM_PPC:     /* R_PPC_NONE.  */
11657     case EM_PPC64:   /* R_PPC64_NONE.  */
11658     case EM_ARM:     /* R_ARM_NONE.  */
11659     case EM_IA_64:   /* R_IA64_NONE.  */
11660     case EM_SH:      /* R_SH_NONE.  */
11661     case EM_S390_OLD:
11662     case EM_S390:    /* R_390_NONE.  */
11663     case EM_CRIS:    /* R_CRIS_NONE.  */
11664     case EM_X86_64:  /* R_X86_64_NONE.  */
11665     case EM_L1OM:    /* R_X86_64_NONE.  */
11666     case EM_K1OM:    /* R_X86_64_NONE.  */
11667     case EM_MN10300: /* R_MN10300_NONE.  */
11668     case EM_FT32:    /* R_FT32_NONE.  */
11669     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11670     case EM_M32R:    /* R_M32R_NONE.  */
11671     case EM_TI_C6000:/* R_C6000_NONE.  */
11672     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11673     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11674     case EM_XC16X:
11675     case EM_C166:    /* R_XC16X_NONE.  */
11676     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11677     case EM_NIOS32:  /* R_NIOS_NONE.  */
11678     case EM_OR1K:    /* R_OR1K_NONE. */
11679       return reloc_type == 0;
11680     case EM_AARCH64:
11681       return reloc_type == 0 || reloc_type == 256;
11682     case EM_NDS32:
11683       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11684               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11685               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11686               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11687               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11688     case EM_XTENSA_OLD:
11689     case EM_XTENSA:
11690       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11691               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11692               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11693               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11694     case EM_METAG:
11695       return reloc_type == 3; /* R_METAG_NONE.  */
11696     }
11697   return FALSE;
11698 }
11699
11700 /* Returns TRUE if there is a relocation against
11701    section NAME at OFFSET bytes.  */
11702
11703 bfd_boolean
11704 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11705 {
11706   Elf_Internal_Rela * relocs;
11707   Elf_Internal_Rela * rp;
11708
11709   if (dsec == NULL || dsec->reloc_info == NULL)
11710     return FALSE;
11711
11712   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11713
11714   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11715     if (rp->r_offset == offset)
11716       return TRUE;
11717
11718    return FALSE;
11719 }
11720
11721 /* Apply relocations to a section.
11722    Note: So far support has been added only for those relocations
11723    which can be found in debug sections.
11724    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11725    loaded relocs.  It is then the caller's responsibility to free them.
11726    FIXME: Add support for more relocations ?  */
11727
11728 static void
11729 apply_relocations (void *                     file,
11730                    const Elf_Internal_Shdr *  section,
11731                    unsigned char *            start,
11732                    bfd_size_type              size,
11733                    void **                     relocs_return,
11734                    unsigned long *            num_relocs_return)
11735 {
11736   Elf_Internal_Shdr * relsec;
11737   unsigned char * end = start + size;
11738
11739   if (relocs_return != NULL)
11740     {
11741       * (Elf_Internal_Rela **) relocs_return = NULL;
11742       * num_relocs_return = 0;
11743     }
11744
11745   if (elf_header.e_type != ET_REL)
11746     return;
11747
11748   /* Find the reloc section associated with the section.  */
11749   for (relsec = section_headers;
11750        relsec < section_headers + elf_header.e_shnum;
11751        ++relsec)
11752     {
11753       bfd_boolean is_rela;
11754       unsigned long num_relocs;
11755       Elf_Internal_Rela * relocs;
11756       Elf_Internal_Rela * rp;
11757       Elf_Internal_Shdr * symsec;
11758       Elf_Internal_Sym * symtab;
11759       unsigned long num_syms;
11760       Elf_Internal_Sym * sym;
11761
11762       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11763           || relsec->sh_info >= elf_header.e_shnum
11764           || section_headers + relsec->sh_info != section
11765           || relsec->sh_size == 0
11766           || relsec->sh_link >= elf_header.e_shnum)
11767         continue;
11768
11769       is_rela = relsec->sh_type == SHT_RELA;
11770
11771       if (is_rela)
11772         {
11773           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11774                                   relsec->sh_size, & relocs, & num_relocs))
11775             return;
11776         }
11777       else
11778         {
11779           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11780                                  relsec->sh_size, & relocs, & num_relocs))
11781             return;
11782         }
11783
11784       /* SH uses RELA but uses in place value instead of the addend field.  */
11785       if (elf_header.e_machine == EM_SH)
11786         is_rela = FALSE;
11787
11788       symsec = section_headers + relsec->sh_link;
11789       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11790
11791       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11792         {
11793           bfd_vma         addend;
11794           unsigned int    reloc_type;
11795           unsigned int    reloc_size;
11796           unsigned char * rloc;
11797           unsigned long   sym_index;
11798
11799           reloc_type = get_reloc_type (rp->r_info);
11800
11801           if (target_specific_reloc_handling (rp, start, symtab))
11802             continue;
11803           else if (is_none_reloc (reloc_type))
11804             continue;
11805           else if (is_32bit_abs_reloc (reloc_type)
11806                    || is_32bit_pcrel_reloc (reloc_type))
11807             reloc_size = 4;
11808           else if (is_64bit_abs_reloc (reloc_type)
11809                    || is_64bit_pcrel_reloc (reloc_type))
11810             reloc_size = 8;
11811           else if (is_24bit_abs_reloc (reloc_type))
11812             reloc_size = 3;
11813           else if (is_16bit_abs_reloc (reloc_type))
11814             reloc_size = 2;
11815           else
11816             {
11817               static unsigned int prev_reloc = 0;
11818               if (reloc_type != prev_reloc)
11819                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11820                       reloc_type, printable_section_name (section));
11821               prev_reloc = reloc_type;
11822               continue;
11823             }
11824
11825           rloc = start + rp->r_offset;
11826           if ((rloc + reloc_size) > end || (rloc < start))
11827             {
11828               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11829                     (unsigned long) rp->r_offset,
11830                     printable_section_name (section));
11831               continue;
11832             }
11833
11834           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11835           if (sym_index >= num_syms)
11836             {
11837               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11838                     sym_index, printable_section_name (section));
11839               continue;
11840             }
11841           sym = symtab + sym_index;
11842
11843           /* If the reloc has a symbol associated with it,
11844              make sure that it is of an appropriate type.
11845
11846              Relocations against symbols without type can happen.
11847              Gcc -feliminate-dwarf2-dups may generate symbols
11848              without type for debug info.
11849
11850              Icc generates relocations against function symbols
11851              instead of local labels.
11852
11853              Relocations against object symbols can happen, eg when
11854              referencing a global array.  For an example of this see
11855              the _clz.o binary in libgcc.a.  */
11856           if (sym != symtab
11857               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11858             {
11859               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11860                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11861                     (long int)(rp - relocs),
11862                     printable_section_name (relsec));
11863               continue;
11864             }
11865
11866           addend = 0;
11867           if (is_rela)
11868             addend += rp->r_addend;
11869           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11870              partial_inplace.  */
11871           if (!is_rela
11872               || (elf_header.e_machine == EM_XTENSA
11873                   && reloc_type == 1)
11874               || ((elf_header.e_machine == EM_PJ
11875                    || elf_header.e_machine == EM_PJ_OLD)
11876                   && reloc_type == 1)
11877               || ((elf_header.e_machine == EM_D30V
11878                    || elf_header.e_machine == EM_CYGNUS_D30V)
11879                   && reloc_type == 12))
11880             addend += byte_get (rloc, reloc_size);
11881
11882           if (is_32bit_pcrel_reloc (reloc_type)
11883               || is_64bit_pcrel_reloc (reloc_type))
11884             {
11885               /* On HPPA, all pc-relative relocations are biased by 8.  */
11886               if (elf_header.e_machine == EM_PARISC)
11887                 addend -= 8;
11888               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11889                         reloc_size);
11890             }
11891           else
11892             byte_put (rloc, addend + sym->st_value, reloc_size);
11893         }
11894
11895       free (symtab);
11896
11897       if (relocs_return)
11898         {
11899           * (Elf_Internal_Rela **) relocs_return = relocs;
11900           * num_relocs_return = num_relocs;
11901         }
11902       else
11903         free (relocs);
11904
11905       break;
11906     }
11907 }
11908
11909 #ifdef SUPPORT_DISASSEMBLY
11910 static int
11911 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11912 {
11913   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11914
11915   /* FIXME: XXX -- to be done --- XXX */
11916
11917   return 1;
11918 }
11919 #endif
11920
11921 /* Reads in the contents of SECTION from FILE, returning a pointer
11922    to a malloc'ed buffer or NULL if something went wrong.  */
11923
11924 static char *
11925 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11926 {
11927   bfd_size_type num_bytes;
11928
11929   num_bytes = section->sh_size;
11930
11931   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11932     {
11933       printf (_("\nSection '%s' has no data to dump.\n"),
11934               printable_section_name (section));
11935       return NULL;
11936     }
11937
11938   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11939                              _("section contents"));
11940 }
11941
11942
11943 static void
11944 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11945 {
11946   Elf_Internal_Shdr * relsec;
11947   bfd_size_type num_bytes;
11948   char * data;
11949   char * end;
11950   char * start;
11951   bfd_boolean some_strings_shown;
11952
11953   start = get_section_contents (section, file);
11954   if (start == NULL)
11955     return;
11956
11957   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11958
11959   /* If the section being dumped has relocations against it the user might
11960      be expecting these relocations to have been applied.  Check for this
11961      case and issue a warning message in order to avoid confusion.
11962      FIXME: Maybe we ought to have an option that dumps a section with
11963      relocs applied ?  */
11964   for (relsec = section_headers;
11965        relsec < section_headers + elf_header.e_shnum;
11966        ++relsec)
11967     {
11968       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11969           || relsec->sh_info >= elf_header.e_shnum
11970           || section_headers + relsec->sh_info != section
11971           || relsec->sh_size == 0
11972           || relsec->sh_link >= elf_header.e_shnum)
11973         continue;
11974
11975       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11976       break;
11977     }
11978
11979   num_bytes = section->sh_size;
11980   data = start;
11981   end  = start + num_bytes;
11982   some_strings_shown = FALSE;
11983
11984   while (data < end)
11985     {
11986       while (!ISPRINT (* data))
11987         if (++ data >= end)
11988           break;
11989
11990       if (data < end)
11991         {
11992           size_t maxlen = end - data;
11993
11994 #ifndef __MSVCRT__
11995           /* PR 11128: Use two separate invocations in order to work
11996              around bugs in the Solaris 8 implementation of printf.  */
11997           printf ("  [%6tx]  ", data - start);
11998 #else
11999           printf ("  [%6Ix]  ", (size_t) (data - start));
12000 #endif
12001           if (maxlen > 0)
12002             {
12003               print_symbol ((int) maxlen, data);
12004               putchar ('\n');
12005               data += strnlen (data, maxlen);
12006             }
12007           else
12008             {
12009               printf (_("<corrupt>\n"));
12010               data = end;
12011             }
12012           some_strings_shown = TRUE;
12013         }
12014     }
12015
12016   if (! some_strings_shown)
12017     printf (_("  No strings found in this section."));
12018
12019   free (start);
12020
12021   putchar ('\n');
12022 }
12023
12024 static void
12025 dump_section_as_bytes (Elf_Internal_Shdr * section,
12026                        FILE * file,
12027                        bfd_boolean relocate)
12028 {
12029   Elf_Internal_Shdr * relsec;
12030   bfd_size_type bytes;
12031   bfd_vma addr;
12032   unsigned char * data;
12033   unsigned char * start;
12034
12035   start = (unsigned char *) get_section_contents (section, file);
12036   if (start == NULL)
12037     return;
12038
12039   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12040
12041   if (relocate)
12042     {
12043       apply_relocations (file, section, start, section->sh_size, NULL, NULL);
12044     }
12045   else
12046     {
12047       /* If the section being dumped has relocations against it the user might
12048          be expecting these relocations to have been applied.  Check for this
12049          case and issue a warning message in order to avoid confusion.
12050          FIXME: Maybe we ought to have an option that dumps a section with
12051          relocs applied ?  */
12052       for (relsec = section_headers;
12053            relsec < section_headers + elf_header.e_shnum;
12054            ++relsec)
12055         {
12056           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12057               || relsec->sh_info >= elf_header.e_shnum
12058               || section_headers + relsec->sh_info != section
12059               || relsec->sh_size == 0
12060               || relsec->sh_link >= elf_header.e_shnum)
12061             continue;
12062
12063           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12064           break;
12065         }
12066     }
12067
12068   addr = section->sh_addr;
12069   bytes = section->sh_size;
12070   data = start;
12071
12072   while (bytes)
12073     {
12074       int j;
12075       int k;
12076       int lbytes;
12077
12078       lbytes = (bytes > 16 ? 16 : bytes);
12079
12080       printf ("  0x%8.8lx ", (unsigned long) addr);
12081
12082       for (j = 0; j < 16; j++)
12083         {
12084           if (j < lbytes)
12085             printf ("%2.2x", data[j]);
12086           else
12087             printf ("  ");
12088
12089           if ((j & 3) == 3)
12090             printf (" ");
12091         }
12092
12093       for (j = 0; j < lbytes; j++)
12094         {
12095           k = data[j];
12096           if (k >= ' ' && k < 0x7f)
12097             printf ("%c", k);
12098           else
12099             printf (".");
12100         }
12101
12102       putchar ('\n');
12103
12104       data  += lbytes;
12105       addr  += lbytes;
12106       bytes -= lbytes;
12107     }
12108
12109   free (start);
12110
12111   putchar ('\n');
12112 }
12113
12114 /* Uncompresses a section that was compressed using zlib, in place.  */
12115
12116 static int
12117 uncompress_section_contents (unsigned char **buffer,
12118                              dwarf_size_type uncompressed_size,
12119                              dwarf_size_type *size)
12120 {
12121   dwarf_size_type compressed_size = *size;
12122   unsigned char * compressed_buffer = *buffer;
12123   unsigned char * uncompressed_buffer;
12124   z_stream strm;
12125   int rc;
12126
12127   /* It is possible the section consists of several compressed
12128      buffers concatenated together, so we uncompress in a loop.  */
12129   /* PR 18313: The state field in the z_stream structure is supposed
12130      to be invisible to the user (ie us), but some compilers will
12131      still complain about it being used without initialisation.  So
12132      we first zero the entire z_stream structure and then set the fields
12133      that we need.  */
12134   memset (& strm, 0, sizeof strm);
12135   strm.avail_in = compressed_size;
12136   strm.next_in = (Bytef *) compressed_buffer;
12137   strm.avail_out = uncompressed_size;
12138   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12139
12140   rc = inflateInit (& strm);
12141   while (strm.avail_in > 0)
12142     {
12143       if (rc != Z_OK)
12144         goto fail;
12145       strm.next_out = ((Bytef *) uncompressed_buffer
12146                        + (uncompressed_size - strm.avail_out));
12147       rc = inflate (&strm, Z_FINISH);
12148       if (rc != Z_STREAM_END)
12149         goto fail;
12150       rc = inflateReset (& strm);
12151     }
12152   rc = inflateEnd (& strm);
12153   if (rc != Z_OK
12154       || strm.avail_out != 0)
12155     goto fail;
12156
12157   *buffer = uncompressed_buffer;
12158   *size = uncompressed_size;
12159   return 1;
12160
12161  fail:
12162   free (uncompressed_buffer);
12163   /* Indicate decompression failure.  */
12164   *buffer = NULL;
12165   return 0;
12166 }
12167
12168 static int
12169 load_specific_debug_section (enum dwarf_section_display_enum debug,
12170                              const Elf_Internal_Shdr * sec, void * file)
12171 {
12172   struct dwarf_section * section = &debug_displays [debug].section;
12173   char buf [64];
12174
12175   /* If it is already loaded, do nothing.  */
12176   if (section->start != NULL)
12177     return 1;
12178
12179   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12180   section->address = sec->sh_addr;
12181   section->user_data = NULL;
12182   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12183                                                sec->sh_offset, 1,
12184                                                sec->sh_size, buf);
12185   if (section->start == NULL)
12186     section->size = 0;
12187   else
12188     {
12189       unsigned char *start = section->start;
12190       dwarf_size_type size = sec->sh_size;
12191       dwarf_size_type uncompressed_size = 0;
12192
12193       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12194         {
12195           Elf_Internal_Chdr chdr;
12196           unsigned int compression_header_size
12197             = get_compression_header (&chdr, start);
12198           if (chdr.ch_type != ELFCOMPRESS_ZLIB
12199               || chdr.ch_addralign != sec->sh_addralign)
12200             return 0;
12201           uncompressed_size = chdr.ch_size;
12202           start += compression_header_size;
12203           size -= compression_header_size;
12204         }
12205       else if (size > 12 && streq ((char *) start, "ZLIB"))
12206         {
12207           /* Read the zlib header.  In this case, it should be "ZLIB"
12208              followed by the uncompressed section size, 8 bytes in
12209              big-endian order.  */
12210           uncompressed_size = start[4]; uncompressed_size <<= 8;
12211           uncompressed_size += start[5]; uncompressed_size <<= 8;
12212           uncompressed_size += start[6]; uncompressed_size <<= 8;
12213           uncompressed_size += start[7]; uncompressed_size <<= 8;
12214           uncompressed_size += start[8]; uncompressed_size <<= 8;
12215           uncompressed_size += start[9]; uncompressed_size <<= 8;
12216           uncompressed_size += start[10]; uncompressed_size <<= 8;
12217           uncompressed_size += start[11];
12218           start += 12;
12219           size -= 12;
12220         }
12221
12222       if (uncompressed_size
12223           && uncompress_section_contents (&start, uncompressed_size,
12224                                           &size))
12225         {
12226           /* Free the compressed buffer, update the section buffer
12227              and the section size if uncompress is successful.  */
12228           free (section->start);
12229           section->start = start;
12230         }
12231       section->size = size;
12232     }
12233
12234   if (section->start == NULL)
12235     return 0;
12236
12237   if (debug_displays [debug].relocate)
12238     apply_relocations ((FILE *) file, sec, section->start, section->size,
12239                        & section->reloc_info, & section->num_relocs);
12240   else
12241     {
12242       section->reloc_info = NULL;
12243       section->num_relocs = 0;
12244     }
12245
12246   return 1;
12247 }
12248
12249 /* If this is not NULL, load_debug_section will only look for sections
12250    within the list of sections given here.  */
12251 unsigned int *section_subset = NULL;
12252
12253 int
12254 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12255 {
12256   struct dwarf_section * section = &debug_displays [debug].section;
12257   Elf_Internal_Shdr * sec;
12258
12259   /* Locate the debug section.  */
12260   sec = find_section_in_set (section->uncompressed_name, section_subset);
12261   if (sec != NULL)
12262     section->name = section->uncompressed_name;
12263   else
12264     {
12265       sec = find_section_in_set (section->compressed_name, section_subset);
12266       if (sec != NULL)
12267         section->name = section->compressed_name;
12268     }
12269   if (sec == NULL)
12270     return 0;
12271
12272   /* If we're loading from a subset of sections, and we've loaded
12273      a section matching this name before, it's likely that it's a
12274      different one.  */
12275   if (section_subset != NULL)
12276     free_debug_section (debug);
12277
12278   return load_specific_debug_section (debug, sec, (FILE *) file);
12279 }
12280
12281 void
12282 free_debug_section (enum dwarf_section_display_enum debug)
12283 {
12284   struct dwarf_section * section = &debug_displays [debug].section;
12285
12286   if (section->start == NULL)
12287     return;
12288
12289   free ((char *) section->start);
12290   section->start = NULL;
12291   section->address = 0;
12292   section->size = 0;
12293 }
12294
12295 static int
12296 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12297 {
12298   char * name = SECTION_NAME (section);
12299   const char * print_name = printable_section_name (section);
12300   bfd_size_type length;
12301   int result = 1;
12302   int i;
12303
12304   length = section->sh_size;
12305   if (length == 0)
12306     {
12307       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12308       return 0;
12309     }
12310   if (section->sh_type == SHT_NOBITS)
12311     {
12312       /* There is no point in dumping the contents of a debugging section
12313          which has the NOBITS type - the bits in the file will be random.
12314          This can happen when a file containing a .eh_frame section is
12315          stripped with the --only-keep-debug command line option.  */
12316       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12317               print_name);
12318       return 0;
12319     }
12320
12321   if (const_strneq (name, ".gnu.linkonce.wi."))
12322     name = ".debug_info";
12323
12324   /* See if we know how to display the contents of this section.  */
12325   for (i = 0; i < max; i++)
12326     if (streq (debug_displays[i].section.uncompressed_name, name)
12327         || (i == line && const_strneq (name, ".debug_line."))
12328         || streq (debug_displays[i].section.compressed_name, name))
12329       {
12330         struct dwarf_section * sec = &debug_displays [i].section;
12331         int secondary = (section != find_section (name));
12332
12333         if (secondary)
12334           free_debug_section ((enum dwarf_section_display_enum) i);
12335
12336         if (i == line && const_strneq (name, ".debug_line."))
12337           sec->name = name;
12338         else if (streq (sec->uncompressed_name, name))
12339           sec->name = sec->uncompressed_name;
12340         else
12341           sec->name = sec->compressed_name;
12342         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12343                                          section, file))
12344           {
12345             /* If this debug section is part of a CU/TU set in a .dwp file,
12346                restrict load_debug_section to the sections in that set.  */
12347             section_subset = find_cu_tu_set (file, shndx);
12348
12349             result &= debug_displays[i].display (sec, file);
12350
12351             section_subset = NULL;
12352
12353             if (secondary || (i != info && i != abbrev))
12354               free_debug_section ((enum dwarf_section_display_enum) i);
12355           }
12356
12357         break;
12358       }
12359
12360   if (i == max)
12361     {
12362       printf (_("Unrecognized debug section: %s\n"), print_name);
12363       result = 0;
12364     }
12365
12366   return result;
12367 }
12368
12369 /* Set DUMP_SECTS for all sections where dumps were requested
12370    based on section name.  */
12371
12372 static void
12373 initialise_dumps_byname (void)
12374 {
12375   struct dump_list_entry * cur;
12376
12377   for (cur = dump_sects_byname; cur; cur = cur->next)
12378     {
12379       unsigned int i;
12380       int any;
12381
12382       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12383         if (streq (SECTION_NAME (section_headers + i), cur->name))
12384           {
12385             request_dump_bynumber (i, cur->type);
12386             any = 1;
12387           }
12388
12389       if (!any)
12390         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12391               cur->name);
12392     }
12393 }
12394
12395 static void
12396 process_section_contents (FILE * file)
12397 {
12398   Elf_Internal_Shdr * section;
12399   unsigned int i;
12400
12401   if (! do_dump)
12402     return;
12403
12404   initialise_dumps_byname ();
12405
12406   for (i = 0, section = section_headers;
12407        i < elf_header.e_shnum && i < num_dump_sects;
12408        i++, section++)
12409     {
12410 #ifdef SUPPORT_DISASSEMBLY
12411       if (dump_sects[i] & DISASS_DUMP)
12412         disassemble_section (section, file);
12413 #endif
12414       if (dump_sects[i] & HEX_DUMP)
12415         dump_section_as_bytes (section, file, FALSE);
12416
12417       if (dump_sects[i] & RELOC_DUMP)
12418         dump_section_as_bytes (section, file, TRUE);
12419
12420       if (dump_sects[i] & STRING_DUMP)
12421         dump_section_as_strings (section, file);
12422
12423       if (dump_sects[i] & DEBUG_DUMP)
12424         display_debug_section (i, section, file);
12425     }
12426
12427   /* Check to see if the user requested a
12428      dump of a section that does not exist.  */
12429   while (i++ < num_dump_sects)
12430     if (dump_sects[i])
12431       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12432 }
12433
12434 static void
12435 process_mips_fpe_exception (int mask)
12436 {
12437   if (mask)
12438     {
12439       int first = 1;
12440       if (mask & OEX_FPU_INEX)
12441         fputs ("INEX", stdout), first = 0;
12442       if (mask & OEX_FPU_UFLO)
12443         printf ("%sUFLO", first ? "" : "|"), first = 0;
12444       if (mask & OEX_FPU_OFLO)
12445         printf ("%sOFLO", first ? "" : "|"), first = 0;
12446       if (mask & OEX_FPU_DIV0)
12447         printf ("%sDIV0", first ? "" : "|"), first = 0;
12448       if (mask & OEX_FPU_INVAL)
12449         printf ("%sINVAL", first ? "" : "|");
12450     }
12451   else
12452     fputs ("0", stdout);
12453 }
12454
12455 /* Display's the value of TAG at location P.  If TAG is
12456    greater than 0 it is assumed to be an unknown tag, and
12457    a message is printed to this effect.  Otherwise it is
12458    assumed that a message has already been printed.
12459
12460    If the bottom bit of TAG is set it assumed to have a
12461    string value, otherwise it is assumed to have an integer
12462    value.
12463
12464    Returns an updated P pointing to the first unread byte
12465    beyond the end of TAG's value.
12466
12467    Reads at or beyond END will not be made.  */
12468
12469 static unsigned char *
12470 display_tag_value (int tag,
12471                    unsigned char * p,
12472                    const unsigned char * const end)
12473 {
12474   unsigned long val;
12475
12476   if (tag > 0)
12477     printf ("  Tag_unknown_%d: ", tag);
12478
12479   if (p >= end)
12480     {
12481       warn (_("<corrupt tag>\n"));
12482     }
12483   else if (tag & 1)
12484     {
12485       /* PR 17531 file: 027-19978-0.004.  */
12486       size_t maxlen = (end - p) - 1;
12487
12488       putchar ('"');
12489       if (maxlen > 0)
12490         {
12491           print_symbol ((int) maxlen, (const char *) p);
12492           p += strnlen ((char *) p, maxlen) + 1;
12493         }
12494       else
12495         {
12496           printf (_("<corrupt string tag>"));
12497           p = (unsigned char *) end;
12498         }
12499       printf ("\"\n");
12500     }
12501   else
12502     {
12503       unsigned int len;
12504
12505       val = read_uleb128 (p, &len, end);
12506       p += len;
12507       printf ("%ld (0x%lx)\n", val, val);
12508     }
12509
12510   assert (p <= end);
12511   return p;
12512 }
12513
12514 /* ARM EABI attributes section.  */
12515 typedef struct
12516 {
12517   unsigned int tag;
12518   const char * name;
12519   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12520   unsigned int type;
12521   const char ** table;
12522 } arm_attr_public_tag;
12523
12524 static const char * arm_attr_tag_CPU_arch[] =
12525   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12526    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12527 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12528 static const char * arm_attr_tag_THUMB_ISA_use[] =
12529   {"No", "Thumb-1", "Thumb-2"};
12530 static const char * arm_attr_tag_FP_arch[] =
12531   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12532    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12533 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12534 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12535   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12536 static const char * arm_attr_tag_PCS_config[] =
12537   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12538    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12539 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12540   {"V6", "SB", "TLS", "Unused"};
12541 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12542   {"Absolute", "PC-relative", "SB-relative", "None"};
12543 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12544   {"Absolute", "PC-relative", "None"};
12545 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12546   {"None", "direct", "GOT-indirect"};
12547 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12548   {"None", "??? 1", "2", "??? 3", "4"};
12549 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12550 static const char * arm_attr_tag_ABI_FP_denormal[] =
12551   {"Unused", "Needed", "Sign only"};
12552 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12553 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12554 static const char * arm_attr_tag_ABI_FP_number_model[] =
12555   {"Unused", "Finite", "RTABI", "IEEE 754"};
12556 static const char * arm_attr_tag_ABI_enum_size[] =
12557   {"Unused", "small", "int", "forced to int"};
12558 static const char * arm_attr_tag_ABI_HardFP_use[] =
12559   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12560 static const char * arm_attr_tag_ABI_VFP_args[] =
12561   {"AAPCS", "VFP registers", "custom", "compatible"};
12562 static const char * arm_attr_tag_ABI_WMMX_args[] =
12563   {"AAPCS", "WMMX registers", "custom"};
12564 static const char * arm_attr_tag_ABI_optimization_goals[] =
12565   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12566     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12567 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12568   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12569     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12570 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12571 static const char * arm_attr_tag_FP_HP_extension[] =
12572   {"Not Allowed", "Allowed"};
12573 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12574   {"None", "IEEE 754", "Alternative Format"};
12575 static const char * arm_attr_tag_MPextension_use[] =
12576   {"Not Allowed", "Allowed"};
12577 static const char * arm_attr_tag_DIV_use[] =
12578   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12579     "Allowed in v7-A with integer division extension"};
12580 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12581 static const char * arm_attr_tag_Virtualization_use[] =
12582   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12583     "TrustZone and Virtualization Extensions"};
12584 static const char * arm_attr_tag_MPextension_use_legacy[] =
12585   {"Not Allowed", "Allowed"};
12586
12587 #define LOOKUP(id, name) \
12588   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12589 static arm_attr_public_tag arm_attr_public_tags[] =
12590 {
12591   {4, "CPU_raw_name", 1, NULL},
12592   {5, "CPU_name", 1, NULL},
12593   LOOKUP(6, CPU_arch),
12594   {7, "CPU_arch_profile", 0, NULL},
12595   LOOKUP(8, ARM_ISA_use),
12596   LOOKUP(9, THUMB_ISA_use),
12597   LOOKUP(10, FP_arch),
12598   LOOKUP(11, WMMX_arch),
12599   LOOKUP(12, Advanced_SIMD_arch),
12600   LOOKUP(13, PCS_config),
12601   LOOKUP(14, ABI_PCS_R9_use),
12602   LOOKUP(15, ABI_PCS_RW_data),
12603   LOOKUP(16, ABI_PCS_RO_data),
12604   LOOKUP(17, ABI_PCS_GOT_use),
12605   LOOKUP(18, ABI_PCS_wchar_t),
12606   LOOKUP(19, ABI_FP_rounding),
12607   LOOKUP(20, ABI_FP_denormal),
12608   LOOKUP(21, ABI_FP_exceptions),
12609   LOOKUP(22, ABI_FP_user_exceptions),
12610   LOOKUP(23, ABI_FP_number_model),
12611   {24, "ABI_align_needed", 0, NULL},
12612   {25, "ABI_align_preserved", 0, NULL},
12613   LOOKUP(26, ABI_enum_size),
12614   LOOKUP(27, ABI_HardFP_use),
12615   LOOKUP(28, ABI_VFP_args),
12616   LOOKUP(29, ABI_WMMX_args),
12617   LOOKUP(30, ABI_optimization_goals),
12618   LOOKUP(31, ABI_FP_optimization_goals),
12619   {32, "compatibility", 0, NULL},
12620   LOOKUP(34, CPU_unaligned_access),
12621   LOOKUP(36, FP_HP_extension),
12622   LOOKUP(38, ABI_FP_16bit_format),
12623   LOOKUP(42, MPextension_use),
12624   LOOKUP(44, DIV_use),
12625   {64, "nodefaults", 0, NULL},
12626   {65, "also_compatible_with", 0, NULL},
12627   LOOKUP(66, T2EE_use),
12628   {67, "conformance", 1, NULL},
12629   LOOKUP(68, Virtualization_use),
12630   LOOKUP(70, MPextension_use_legacy)
12631 };
12632 #undef LOOKUP
12633
12634 static unsigned char *
12635 display_arm_attribute (unsigned char * p,
12636                        const unsigned char * const end)
12637 {
12638   unsigned int tag;
12639   unsigned int len;
12640   unsigned int val;
12641   arm_attr_public_tag * attr;
12642   unsigned i;
12643   unsigned int type;
12644
12645   tag = read_uleb128 (p, &len, end);
12646   p += len;
12647   attr = NULL;
12648   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12649     {
12650       if (arm_attr_public_tags[i].tag == tag)
12651         {
12652           attr = &arm_attr_public_tags[i];
12653           break;
12654         }
12655     }
12656
12657   if (attr)
12658     {
12659       printf ("  Tag_%s: ", attr->name);
12660       switch (attr->type)
12661         {
12662         case 0:
12663           switch (tag)
12664             {
12665             case 7: /* Tag_CPU_arch_profile.  */
12666               val = read_uleb128 (p, &len, end);
12667               p += len;
12668               switch (val)
12669                 {
12670                 case 0: printf (_("None\n")); break;
12671                 case 'A': printf (_("Application\n")); break;
12672                 case 'R': printf (_("Realtime\n")); break;
12673                 case 'M': printf (_("Microcontroller\n")); break;
12674                 case 'S': printf (_("Application or Realtime\n")); break;
12675                 default: printf ("??? (%d)\n", val); break;
12676                 }
12677               break;
12678
12679             case 24: /* Tag_align_needed.  */
12680               val = read_uleb128 (p, &len, end);
12681               p += len;
12682               switch (val)
12683                 {
12684                 case 0: printf (_("None\n")); break;
12685                 case 1: printf (_("8-byte\n")); break;
12686                 case 2: printf (_("4-byte\n")); break;
12687                 case 3: printf ("??? 3\n"); break;
12688                 default:
12689                   if (val <= 12)
12690                     printf (_("8-byte and up to %d-byte extended\n"),
12691                             1 << val);
12692                   else
12693                     printf ("??? (%d)\n", val);
12694                   break;
12695                 }
12696               break;
12697
12698             case 25: /* Tag_align_preserved.  */
12699               val = read_uleb128 (p, &len, end);
12700               p += len;
12701               switch (val)
12702                 {
12703                 case 0: printf (_("None\n")); break;
12704                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12705                 case 2: printf (_("8-byte\n")); break;
12706                 case 3: printf ("??? 3\n"); break;
12707                 default:
12708                   if (val <= 12)
12709                     printf (_("8-byte and up to %d-byte extended\n"),
12710                             1 << val);
12711                   else
12712                     printf ("??? (%d)\n", val);
12713                   break;
12714                 }
12715               break;
12716
12717             case 32: /* Tag_compatibility.  */
12718               {
12719                 val = read_uleb128 (p, &len, end);
12720                 p += len;
12721                 printf (_("flag = %d, vendor = "), val);
12722                 if (p < end - 1)
12723                   {
12724                     size_t maxlen = (end - p) - 1;
12725
12726                     print_symbol ((int) maxlen, (const char *) p);
12727                     p += strnlen ((char *) p, maxlen) + 1;
12728                   }
12729                 else
12730                   {
12731                     printf (_("<corrupt>"));
12732                     p = (unsigned char *) end;
12733                   }
12734                 putchar ('\n');
12735               }
12736               break;
12737
12738             case 64: /* Tag_nodefaults.  */
12739               /* PR 17531: file: 001-505008-0.01.  */
12740               if (p < end)
12741                 p++;
12742               printf (_("True\n"));
12743               break;
12744
12745             case 65: /* Tag_also_compatible_with.  */
12746               val = read_uleb128 (p, &len, end);
12747               p += len;
12748               if (val == 6 /* Tag_CPU_arch.  */)
12749                 {
12750                   val = read_uleb128 (p, &len, end);
12751                   p += len;
12752                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12753                     printf ("??? (%d)\n", val);
12754                   else
12755                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12756                 }
12757               else
12758                 printf ("???\n");
12759               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12760                 ;
12761               break;
12762
12763             default:
12764               printf (_("<unknown: %d>\n"), tag);
12765               break;
12766             }
12767           return p;
12768
12769         case 1:
12770           return display_tag_value (-1, p, end);
12771         case 2:
12772           return display_tag_value (0, p, end);
12773
12774         default:
12775           assert (attr->type & 0x80);
12776           val = read_uleb128 (p, &len, end);
12777           p += len;
12778           type = attr->type & 0x7f;
12779           if (val >= type)
12780             printf ("??? (%d)\n", val);
12781           else
12782             printf ("%s\n", attr->table[val]);
12783           return p;
12784         }
12785     }
12786
12787   return display_tag_value (tag, p, end);
12788 }
12789
12790 static unsigned char *
12791 display_gnu_attribute (unsigned char * p,
12792                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12793                        const unsigned char * const end)
12794 {
12795   int tag;
12796   unsigned int len;
12797   int val;
12798
12799   tag = read_uleb128 (p, &len, end);
12800   p += len;
12801
12802   /* Tag_compatibility is the only generic GNU attribute defined at
12803      present.  */
12804   if (tag == 32)
12805     {
12806       val = read_uleb128 (p, &len, end);
12807       p += len;
12808
12809       printf (_("flag = %d, vendor = "), val);
12810       if (p == end)
12811         {
12812           printf (_("<corrupt>\n"));
12813           warn (_("corrupt vendor attribute\n"));
12814         }
12815       else
12816         {
12817           if (p < end - 1)
12818             {
12819               size_t maxlen = (end - p) - 1;
12820
12821               print_symbol ((int) maxlen, (const char *) p);
12822               p += strnlen ((char *) p, maxlen) + 1;
12823             }
12824           else
12825             {
12826               printf (_("<corrupt>"));
12827               p = (unsigned char *) end;
12828             }
12829           putchar ('\n');
12830         }
12831       return p;
12832     }
12833
12834   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12835     return display_proc_gnu_attribute (p, tag, end);
12836
12837   return display_tag_value (tag, p, end);
12838 }
12839
12840 static unsigned char *
12841 display_power_gnu_attribute (unsigned char * p,
12842                              int tag,
12843                              const unsigned char * const end)
12844 {
12845   unsigned int len;
12846   int val;
12847
12848   if (tag == Tag_GNU_Power_ABI_FP)
12849     {
12850       val = read_uleb128 (p, &len, end);
12851       p += len;
12852       printf ("  Tag_GNU_Power_ABI_FP: ");
12853
12854       switch (val)
12855         {
12856         case 0:
12857           printf (_("Hard or soft float\n"));
12858           break;
12859         case 1:
12860           printf (_("Hard float\n"));
12861           break;
12862         case 2:
12863           printf (_("Soft float\n"));
12864           break;
12865         case 3:
12866           printf (_("Single-precision hard float\n"));
12867           break;
12868         default:
12869           printf ("??? (%d)\n", val);
12870           break;
12871         }
12872       return p;
12873    }
12874
12875   if (tag == Tag_GNU_Power_ABI_Vector)
12876     {
12877       val = read_uleb128 (p, &len, end);
12878       p += len;
12879       printf ("  Tag_GNU_Power_ABI_Vector: ");
12880       switch (val)
12881         {
12882         case 0:
12883           printf (_("Any\n"));
12884           break;
12885         case 1:
12886           printf (_("Generic\n"));
12887           break;
12888         case 2:
12889           printf ("AltiVec\n");
12890           break;
12891         case 3:
12892           printf ("SPE\n");
12893           break;
12894         default:
12895           printf ("??? (%d)\n", val);
12896           break;
12897         }
12898       return p;
12899    }
12900
12901   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12902     {
12903       if (p == end)
12904         {
12905           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12906           return p;
12907         }
12908
12909       val = read_uleb128 (p, &len, end);
12910       p += len;
12911       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12912       switch (val)
12913        {
12914        case 0:
12915          printf (_("Any\n"));
12916          break;
12917        case 1:
12918          printf ("r3/r4\n");
12919          break;
12920        case 2:
12921          printf (_("Memory\n"));
12922          break;
12923        default:
12924          printf ("??? (%d)\n", val);
12925          break;
12926        }
12927       return p;
12928     }
12929
12930   return display_tag_value (tag & 1, p, end);
12931 }
12932
12933 static unsigned char *
12934 display_s390_gnu_attribute (unsigned char * p,
12935                             int tag,
12936                             const unsigned char * const end)
12937 {
12938   unsigned int len;
12939   int val;
12940
12941   if (tag == Tag_GNU_S390_ABI_Vector)
12942     {
12943       val = read_uleb128 (p, &len, end);
12944       p += len;
12945       printf ("  Tag_GNU_S390_ABI_Vector: ");
12946
12947       switch (val)
12948         {
12949         case 0:
12950           printf (_("any\n"));
12951           break;
12952         case 1:
12953           printf (_("software\n"));
12954           break;
12955         case 2:
12956           printf (_("hardware\n"));
12957           break;
12958         default:
12959           printf ("??? (%d)\n", val);
12960           break;
12961         }
12962       return p;
12963    }
12964
12965   return display_tag_value (tag & 1, p, end);
12966 }
12967
12968 static void
12969 display_sparc_hwcaps (int mask)
12970 {
12971   if (mask)
12972     {
12973       int first = 1;
12974
12975       if (mask & ELF_SPARC_HWCAP_MUL32)
12976         fputs ("mul32", stdout), first = 0;
12977       if (mask & ELF_SPARC_HWCAP_DIV32)
12978         printf ("%sdiv32", first ? "" : "|"), first = 0;
12979       if (mask & ELF_SPARC_HWCAP_FSMULD)
12980         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12981       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12982         printf ("%sv8plus", first ? "" : "|"), first = 0;
12983       if (mask & ELF_SPARC_HWCAP_POPC)
12984         printf ("%spopc", first ? "" : "|"), first = 0;
12985       if (mask & ELF_SPARC_HWCAP_VIS)
12986         printf ("%svis", first ? "" : "|"), first = 0;
12987       if (mask & ELF_SPARC_HWCAP_VIS2)
12988         printf ("%svis2", first ? "" : "|"), first = 0;
12989       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12990         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12991       if (mask & ELF_SPARC_HWCAP_FMAF)
12992         printf ("%sfmaf", first ? "" : "|"), first = 0;
12993       if (mask & ELF_SPARC_HWCAP_VIS3)
12994         printf ("%svis3", first ? "" : "|"), first = 0;
12995       if (mask & ELF_SPARC_HWCAP_HPC)
12996         printf ("%shpc", first ? "" : "|"), first = 0;
12997       if (mask & ELF_SPARC_HWCAP_RANDOM)
12998         printf ("%srandom", first ? "" : "|"), first = 0;
12999       if (mask & ELF_SPARC_HWCAP_TRANS)
13000         printf ("%strans", first ? "" : "|"), first = 0;
13001       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13002         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13003       if (mask & ELF_SPARC_HWCAP_IMA)
13004         printf ("%sima", first ? "" : "|"), first = 0;
13005       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13006         printf ("%scspare", first ? "" : "|"), first = 0;
13007     }
13008   else
13009     fputc ('0', stdout);
13010   fputc ('\n', stdout);
13011 }
13012
13013 static void
13014 display_sparc_hwcaps2 (int mask)
13015 {
13016   if (mask)
13017     {
13018       int first = 1;
13019
13020       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13021         fputs ("fjathplus", stdout), first = 0;
13022       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13023         printf ("%svis3b", first ? "" : "|"), first = 0;
13024       if (mask & ELF_SPARC_HWCAP2_ADP)
13025         printf ("%sadp", first ? "" : "|"), first = 0;
13026       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13027         printf ("%ssparc5", first ? "" : "|"), first = 0;
13028       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13029         printf ("%smwait", first ? "" : "|"), first = 0;
13030       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13031         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13032       if (mask & ELF_SPARC_HWCAP2_XMONT)
13033         printf ("%sxmont2", first ? "" : "|"), first = 0;
13034       if (mask & ELF_SPARC_HWCAP2_NSEC)
13035         printf ("%snsec", first ? "" : "|"), first = 0;
13036       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13037         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13038       if (mask & ELF_SPARC_HWCAP2_FJDES)
13039         printf ("%sfjdes", first ? "" : "|"), first = 0;
13040       if (mask & ELF_SPARC_HWCAP2_FJAES)
13041         printf ("%sfjaes", first ? "" : "|"), first = 0;
13042     }
13043   else
13044     fputc ('0', stdout);
13045   fputc ('\n', stdout);
13046 }
13047
13048 static unsigned char *
13049 display_sparc_gnu_attribute (unsigned char * p,
13050                              int tag,
13051                              const unsigned char * const end)
13052 {
13053   unsigned int len;
13054   int val;
13055
13056   if (tag == Tag_GNU_Sparc_HWCAPS)
13057     {
13058       val = read_uleb128 (p, &len, end);
13059       p += len;
13060       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13061       display_sparc_hwcaps (val);
13062       return p;
13063     }
13064   if (tag == Tag_GNU_Sparc_HWCAPS2)
13065     {
13066       val = read_uleb128 (p, &len, end);
13067       p += len;
13068       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13069       display_sparc_hwcaps2 (val);
13070       return p;
13071     }
13072
13073   return display_tag_value (tag, p, end);
13074 }
13075
13076 static void
13077 print_mips_fp_abi_value (int val)
13078 {
13079   switch (val)
13080     {
13081     case Val_GNU_MIPS_ABI_FP_ANY:
13082       printf (_("Hard or soft float\n"));
13083       break;
13084     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13085       printf (_("Hard float (double precision)\n"));
13086       break;
13087     case Val_GNU_MIPS_ABI_FP_SINGLE:
13088       printf (_("Hard float (single precision)\n"));
13089       break;
13090     case Val_GNU_MIPS_ABI_FP_SOFT:
13091       printf (_("Soft float\n"));
13092       break;
13093     case Val_GNU_MIPS_ABI_FP_OLD_64:
13094       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13095       break;
13096     case Val_GNU_MIPS_ABI_FP_XX:
13097       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13098       break;
13099     case Val_GNU_MIPS_ABI_FP_64:
13100       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13101       break;
13102     case Val_GNU_MIPS_ABI_FP_64A:
13103       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13104       break;
13105     default:
13106       printf ("??? (%d)\n", val);
13107       break;
13108     }
13109 }
13110
13111 static unsigned char *
13112 display_mips_gnu_attribute (unsigned char * p,
13113                             int tag,
13114                             const unsigned char * const end)
13115 {
13116   if (tag == Tag_GNU_MIPS_ABI_FP)
13117     {
13118       unsigned int len;
13119       int val;
13120
13121       val = read_uleb128 (p, &len, end);
13122       p += len;
13123       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13124
13125       print_mips_fp_abi_value (val);
13126
13127       return p;
13128    }
13129
13130   if (tag == Tag_GNU_MIPS_ABI_MSA)
13131     {
13132       unsigned int len;
13133       int val;
13134
13135       val = read_uleb128 (p, &len, end);
13136       p += len;
13137       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13138
13139       switch (val)
13140         {
13141         case Val_GNU_MIPS_ABI_MSA_ANY:
13142           printf (_("Any MSA or not\n"));
13143           break;
13144         case Val_GNU_MIPS_ABI_MSA_128:
13145           printf (_("128-bit MSA\n"));
13146           break;
13147         default:
13148           printf ("??? (%d)\n", val);
13149           break;
13150         }
13151       return p;
13152     }
13153
13154   return display_tag_value (tag & 1, p, end);
13155 }
13156
13157 static unsigned char *
13158 display_tic6x_attribute (unsigned char * p,
13159                          const unsigned char * const end)
13160 {
13161   int tag;
13162   unsigned int len;
13163   int val;
13164
13165   tag = read_uleb128 (p, &len, end);
13166   p += len;
13167
13168   switch (tag)
13169     {
13170     case Tag_ISA:
13171       val = read_uleb128 (p, &len, end);
13172       p += len;
13173       printf ("  Tag_ISA: ");
13174
13175       switch (val)
13176         {
13177         case C6XABI_Tag_ISA_none:
13178           printf (_("None\n"));
13179           break;
13180         case C6XABI_Tag_ISA_C62X:
13181           printf ("C62x\n");
13182           break;
13183         case C6XABI_Tag_ISA_C67X:
13184           printf ("C67x\n");
13185           break;
13186         case C6XABI_Tag_ISA_C67XP:
13187           printf ("C67x+\n");
13188           break;
13189         case C6XABI_Tag_ISA_C64X:
13190           printf ("C64x\n");
13191           break;
13192         case C6XABI_Tag_ISA_C64XP:
13193           printf ("C64x+\n");
13194           break;
13195         case C6XABI_Tag_ISA_C674X:
13196           printf ("C674x\n");
13197           break;
13198         default:
13199           printf ("??? (%d)\n", val);
13200           break;
13201         }
13202       return p;
13203
13204     case Tag_ABI_wchar_t:
13205       val = read_uleb128 (p, &len, end);
13206       p += len;
13207       printf ("  Tag_ABI_wchar_t: ");
13208       switch (val)
13209         {
13210         case 0:
13211           printf (_("Not used\n"));
13212           break;
13213         case 1:
13214           printf (_("2 bytes\n"));
13215           break;
13216         case 2:
13217           printf (_("4 bytes\n"));
13218           break;
13219         default:
13220           printf ("??? (%d)\n", val);
13221           break;
13222         }
13223       return p;
13224
13225     case Tag_ABI_stack_align_needed:
13226       val = read_uleb128 (p, &len, end);
13227       p += len;
13228       printf ("  Tag_ABI_stack_align_needed: ");
13229       switch (val)
13230         {
13231         case 0:
13232           printf (_("8-byte\n"));
13233           break;
13234         case 1:
13235           printf (_("16-byte\n"));
13236           break;
13237         default:
13238           printf ("??? (%d)\n", val);
13239           break;
13240         }
13241       return p;
13242
13243     case Tag_ABI_stack_align_preserved:
13244       val = read_uleb128 (p, &len, end);
13245       p += len;
13246       printf ("  Tag_ABI_stack_align_preserved: ");
13247       switch (val)
13248         {
13249         case 0:
13250           printf (_("8-byte\n"));
13251           break;
13252         case 1:
13253           printf (_("16-byte\n"));
13254           break;
13255         default:
13256           printf ("??? (%d)\n", val);
13257           break;
13258         }
13259       return p;
13260
13261     case Tag_ABI_DSBT:
13262       val = read_uleb128 (p, &len, end);
13263       p += len;
13264       printf ("  Tag_ABI_DSBT: ");
13265       switch (val)
13266         {
13267         case 0:
13268           printf (_("DSBT addressing not used\n"));
13269           break;
13270         case 1:
13271           printf (_("DSBT addressing used\n"));
13272           break;
13273         default:
13274           printf ("??? (%d)\n", val);
13275           break;
13276         }
13277       return p;
13278
13279     case Tag_ABI_PID:
13280       val = read_uleb128 (p, &len, end);
13281       p += len;
13282       printf ("  Tag_ABI_PID: ");
13283       switch (val)
13284         {
13285         case 0:
13286           printf (_("Data addressing position-dependent\n"));
13287           break;
13288         case 1:
13289           printf (_("Data addressing position-independent, GOT near DP\n"));
13290           break;
13291         case 2:
13292           printf (_("Data addressing position-independent, GOT far from DP\n"));
13293           break;
13294         default:
13295           printf ("??? (%d)\n", val);
13296           break;
13297         }
13298       return p;
13299
13300     case Tag_ABI_PIC:
13301       val = read_uleb128 (p, &len, end);
13302       p += len;
13303       printf ("  Tag_ABI_PIC: ");
13304       switch (val)
13305         {
13306         case 0:
13307           printf (_("Code addressing position-dependent\n"));
13308           break;
13309         case 1:
13310           printf (_("Code addressing position-independent\n"));
13311           break;
13312         default:
13313           printf ("??? (%d)\n", val);
13314           break;
13315         }
13316       return p;
13317
13318     case Tag_ABI_array_object_alignment:
13319       val = read_uleb128 (p, &len, end);
13320       p += len;
13321       printf ("  Tag_ABI_array_object_alignment: ");
13322       switch (val)
13323         {
13324         case 0:
13325           printf (_("8-byte\n"));
13326           break;
13327         case 1:
13328           printf (_("4-byte\n"));
13329           break;
13330         case 2:
13331           printf (_("16-byte\n"));
13332           break;
13333         default:
13334           printf ("??? (%d)\n", val);
13335           break;
13336         }
13337       return p;
13338
13339     case Tag_ABI_array_object_align_expected:
13340       val = read_uleb128 (p, &len, end);
13341       p += len;
13342       printf ("  Tag_ABI_array_object_align_expected: ");
13343       switch (val)
13344         {
13345         case 0:
13346           printf (_("8-byte\n"));
13347           break;
13348         case 1:
13349           printf (_("4-byte\n"));
13350           break;
13351         case 2:
13352           printf (_("16-byte\n"));
13353           break;
13354         default:
13355           printf ("??? (%d)\n", val);
13356           break;
13357         }
13358       return p;
13359
13360     case Tag_ABI_compatibility:
13361       {
13362         val = read_uleb128 (p, &len, end);
13363         p += len;
13364         printf ("  Tag_ABI_compatibility: ");
13365         printf (_("flag = %d, vendor = "), val);
13366         if (p < end - 1)
13367           {
13368             size_t maxlen = (end - p) - 1;
13369
13370             print_symbol ((int) maxlen, (const char *) p);
13371             p += strnlen ((char *) p, maxlen) + 1;
13372           }
13373         else
13374           {
13375             printf (_("<corrupt>"));
13376             p = (unsigned char *) end;
13377           }
13378         putchar ('\n');
13379         return p;
13380       }
13381
13382     case Tag_ABI_conformance:
13383       {
13384         printf ("  Tag_ABI_conformance: \"");
13385         if (p < end - 1)
13386           {
13387             size_t maxlen = (end - p) - 1;
13388
13389             print_symbol ((int) maxlen, (const char *) p);
13390             p += strnlen ((char *) p, maxlen) + 1;
13391           }
13392         else
13393           {
13394             printf (_("<corrupt>"));
13395             p = (unsigned char *) end;
13396           }
13397         printf ("\"\n");
13398         return p;
13399       }
13400     }
13401
13402   return display_tag_value (tag, p, end);
13403 }
13404
13405 static void
13406 display_raw_attribute (unsigned char * p, unsigned char * end)
13407 {
13408   unsigned long addr = 0;
13409   size_t bytes = end - p;
13410
13411   assert (end > p);
13412   while (bytes)
13413     {
13414       int j;
13415       int k;
13416       int lbytes = (bytes > 16 ? 16 : bytes);
13417
13418       printf ("  0x%8.8lx ", addr);
13419
13420       for (j = 0; j < 16; j++)
13421         {
13422           if (j < lbytes)
13423             printf ("%2.2x", p[j]);
13424           else
13425             printf ("  ");
13426
13427           if ((j & 3) == 3)
13428             printf (" ");
13429         }
13430
13431       for (j = 0; j < lbytes; j++)
13432         {
13433           k = p[j];
13434           if (k >= ' ' && k < 0x7f)
13435             printf ("%c", k);
13436           else
13437             printf (".");
13438         }
13439
13440       putchar ('\n');
13441
13442       p  += lbytes;
13443       bytes -= lbytes;
13444       addr += lbytes;
13445     }
13446
13447   putchar ('\n');
13448 }
13449
13450 static unsigned char *
13451 display_msp430x_attribute (unsigned char * p,
13452                            const unsigned char * const end)
13453 {
13454   unsigned int len;
13455   int val;
13456   int tag;
13457
13458   tag = read_uleb128 (p, & len, end);
13459   p += len;
13460
13461   switch (tag)
13462     {
13463     case OFBA_MSPABI_Tag_ISA:
13464       val = read_uleb128 (p, &len, end);
13465       p += len;
13466       printf ("  Tag_ISA: ");
13467       switch (val)
13468         {
13469         case 0: printf (_("None\n")); break;
13470         case 1: printf (_("MSP430\n")); break;
13471         case 2: printf (_("MSP430X\n")); break;
13472         default: printf ("??? (%d)\n", val); break;
13473         }
13474       break;
13475
13476     case OFBA_MSPABI_Tag_Code_Model:
13477       val = read_uleb128 (p, &len, end);
13478       p += len;
13479       printf ("  Tag_Code_Model: ");
13480       switch (val)
13481         {
13482         case 0: printf (_("None\n")); break;
13483         case 1: printf (_("Small\n")); break;
13484         case 2: printf (_("Large\n")); break;
13485         default: printf ("??? (%d)\n", val); break;
13486         }
13487       break;
13488
13489     case OFBA_MSPABI_Tag_Data_Model:
13490       val = read_uleb128 (p, &len, end);
13491       p += len;
13492       printf ("  Tag_Data_Model: ");
13493       switch (val)
13494         {
13495         case 0: printf (_("None\n")); break;
13496         case 1: printf (_("Small\n")); break;
13497         case 2: printf (_("Large\n")); break;
13498         case 3: printf (_("Restricted Large\n")); break;
13499         default: printf ("??? (%d)\n", val); break;
13500         }
13501       break;
13502
13503     default:
13504       printf (_("  <unknown tag %d>: "), tag);
13505
13506       if (tag & 1)
13507         {
13508           putchar ('"');
13509           if (p < end - 1)
13510             {
13511               size_t maxlen = (end - p) - 1;
13512
13513               print_symbol ((int) maxlen, (const char *) p);
13514               p += strnlen ((char *) p, maxlen) + 1;
13515             }
13516           else
13517             {
13518               printf (_("<corrupt>"));
13519               p = (unsigned char *) end;
13520             }
13521           printf ("\"\n");
13522         }
13523       else
13524         {
13525           val = read_uleb128 (p, &len, end);
13526           p += len;
13527           printf ("%d (0x%x)\n", val, val);
13528         }
13529       break;
13530    }
13531
13532   assert (p <= end);
13533   return p;
13534 }
13535
13536 static int
13537 process_attributes (FILE * file,
13538                     const char * public_name,
13539                     unsigned int proc_type,
13540                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13541                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13542 {
13543   Elf_Internal_Shdr * sect;
13544   unsigned i;
13545
13546   /* Find the section header so that we get the size.  */
13547   for (i = 0, sect = section_headers;
13548        i < elf_header.e_shnum;
13549        i++, sect++)
13550     {
13551       unsigned char * contents;
13552       unsigned char * p;
13553
13554       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13555         continue;
13556
13557       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13558                                              sect->sh_size, _("attributes"));
13559       if (contents == NULL)
13560         continue;
13561
13562       p = contents;
13563       if (*p == 'A')
13564         {
13565           bfd_vma section_len;
13566
13567           section_len = sect->sh_size - 1;
13568           p++;
13569
13570           while (section_len > 0)
13571             {
13572               bfd_vma attr_len;
13573               unsigned int namelen;
13574               bfd_boolean public_section;
13575               bfd_boolean gnu_section;
13576
13577               if (section_len <= 4)
13578                 {
13579                   error (_("Tag section ends prematurely\n"));
13580                   break;
13581                 }
13582               attr_len = byte_get (p, 4);
13583               p += 4;
13584
13585               if (attr_len > section_len)
13586                 {
13587                   error (_("Bad attribute length (%u > %u)\n"),
13588                           (unsigned) attr_len, (unsigned) section_len);
13589                   attr_len = section_len;
13590                 }
13591               /* PR 17531: file: 001-101425-0.004  */
13592               else if (attr_len < 5)
13593                 {
13594                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13595                   break;
13596                 }
13597
13598               section_len -= attr_len;
13599               attr_len -= 4;
13600
13601               namelen = strnlen ((char *) p, attr_len) + 1;
13602               if (namelen == 0 || namelen >= attr_len)
13603                 {
13604                   error (_("Corrupt attribute section name\n"));
13605                   break;
13606                 }
13607
13608               printf (_("Attribute Section: "));
13609               print_symbol (INT_MAX, (const char *) p);
13610               putchar ('\n');
13611
13612               if (public_name && streq ((char *) p, public_name))
13613                 public_section = TRUE;
13614               else
13615                 public_section = FALSE;
13616
13617               if (streq ((char *) p, "gnu"))
13618                 gnu_section = TRUE;
13619               else
13620                 gnu_section = FALSE;
13621
13622               p += namelen;
13623               attr_len -= namelen;
13624
13625               while (attr_len > 0 && p < contents + sect->sh_size)
13626                 {
13627                   int tag;
13628                   int val;
13629                   bfd_vma size;
13630                   unsigned char * end;
13631
13632                   /* PR binutils/17531: Safe handling of corrupt files.  */
13633                   if (attr_len < 6)
13634                     {
13635                       error (_("Unused bytes at end of section\n"));
13636                       section_len = 0;
13637                       break;
13638                     }
13639
13640                   tag = *(p++);
13641                   size = byte_get (p, 4);
13642                   if (size > attr_len)
13643                     {
13644                       error (_("Bad subsection length (%u > %u)\n"),
13645                               (unsigned) size, (unsigned) attr_len);
13646                       size = attr_len;
13647                     }
13648                   /* PR binutils/17531: Safe handling of corrupt files.  */
13649                   if (size < 6)
13650                     {
13651                       error (_("Bad subsection length (%u < 6)\n"),
13652                               (unsigned) size);
13653                       section_len = 0;
13654                       break;
13655                     }
13656
13657                   attr_len -= size;
13658                   end = p + size - 1;
13659                   assert (end <= contents + sect->sh_size);
13660                   p += 4;
13661
13662                   switch (tag)
13663                     {
13664                     case 1:
13665                       printf (_("File Attributes\n"));
13666                       break;
13667                     case 2:
13668                       printf (_("Section Attributes:"));
13669                       goto do_numlist;
13670                     case 3:
13671                       printf (_("Symbol Attributes:"));
13672                     do_numlist:
13673                       for (;;)
13674                         {
13675                           unsigned int j;
13676
13677                           val = read_uleb128 (p, &j, end);
13678                           p += j;
13679                           if (val == 0)
13680                             break;
13681                           printf (" %d", val);
13682                         }
13683                       printf ("\n");
13684                       break;
13685                     default:
13686                       printf (_("Unknown tag: %d\n"), tag);
13687                       public_section = FALSE;
13688                       break;
13689                     }
13690
13691                   if (public_section && display_pub_attribute != NULL)
13692                     {
13693                       while (p < end)
13694                         p = display_pub_attribute (p, end);
13695                       assert (p <= end);
13696                     }
13697                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13698                     {
13699                       while (p < end)
13700                         p = display_gnu_attribute (p,
13701                                                    display_proc_gnu_attribute,
13702                                                    end);
13703                       assert (p <= end);
13704                     }
13705                   else if (p < end)
13706                     {
13707                       printf (_("  Unknown attribute:\n"));
13708                       display_raw_attribute (p, end);
13709                       p = end;
13710                     }
13711                   else
13712                     attr_len = 0;
13713                 }
13714             }
13715         }
13716       else
13717         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13718
13719       free (contents);
13720     }
13721   return 1;
13722 }
13723
13724 static int
13725 process_arm_specific (FILE * file)
13726 {
13727   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13728                              display_arm_attribute, NULL);
13729 }
13730
13731 static int
13732 process_power_specific (FILE * file)
13733 {
13734   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13735                              display_power_gnu_attribute);
13736 }
13737
13738 static int
13739 process_s390_specific (FILE * file)
13740 {
13741   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13742                              display_s390_gnu_attribute);
13743 }
13744
13745 static int
13746 process_sparc_specific (FILE * file)
13747 {
13748   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13749                              display_sparc_gnu_attribute);
13750 }
13751
13752 static int
13753 process_tic6x_specific (FILE * file)
13754 {
13755   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13756                              display_tic6x_attribute, NULL);
13757 }
13758
13759 static int
13760 process_msp430x_specific (FILE * file)
13761 {
13762   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13763                              display_msp430x_attribute, NULL);
13764 }
13765
13766 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13767    Print the Address, Access and Initial fields of an entry at VMA ADDR
13768    and return the VMA of the next entry, or -1 if there was a problem.
13769    Does not read from DATA_END or beyond.  */
13770
13771 static bfd_vma
13772 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13773                       unsigned char * data_end)
13774 {
13775   printf ("  ");
13776   print_vma (addr, LONG_HEX);
13777   printf (" ");
13778   if (addr < pltgot + 0xfff0)
13779     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13780   else
13781     printf ("%10s", "");
13782   printf (" ");
13783   if (data == NULL)
13784     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13785   else
13786     {
13787       bfd_vma entry;
13788       unsigned char * from = data + addr - pltgot;
13789
13790       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13791         {
13792           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13793           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13794           return (bfd_vma) -1;
13795         }
13796       else
13797         {
13798           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13799           print_vma (entry, LONG_HEX);
13800         }
13801     }
13802   return addr + (is_32bit_elf ? 4 : 8);
13803 }
13804
13805 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13806    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13807    ADDR and return the VMA of the next entry.  */
13808
13809 static bfd_vma
13810 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13811 {
13812   printf ("  ");
13813   print_vma (addr, LONG_HEX);
13814   printf (" ");
13815   if (data == NULL)
13816     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13817   else
13818     {
13819       bfd_vma entry;
13820
13821       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13822       print_vma (entry, LONG_HEX);
13823     }
13824   return addr + (is_32bit_elf ? 4 : 8);
13825 }
13826
13827 static void
13828 print_mips_ases (unsigned int mask)
13829 {
13830   if (mask & AFL_ASE_DSP)
13831     fputs ("\n\tDSP ASE", stdout);
13832   if (mask & AFL_ASE_DSPR2)
13833     fputs ("\n\tDSP R2 ASE", stdout);
13834   if (mask & AFL_ASE_EVA)
13835     fputs ("\n\tEnhanced VA Scheme", stdout);
13836   if (mask & AFL_ASE_MCU)
13837     fputs ("\n\tMCU (MicroController) ASE", stdout);
13838   if (mask & AFL_ASE_MDMX)
13839     fputs ("\n\tMDMX ASE", stdout);
13840   if (mask & AFL_ASE_MIPS3D)
13841     fputs ("\n\tMIPS-3D ASE", stdout);
13842   if (mask & AFL_ASE_MT)
13843     fputs ("\n\tMT ASE", stdout);
13844   if (mask & AFL_ASE_SMARTMIPS)
13845     fputs ("\n\tSmartMIPS ASE", stdout);
13846   if (mask & AFL_ASE_VIRT)
13847     fputs ("\n\tVZ ASE", stdout);
13848   if (mask & AFL_ASE_MSA)
13849     fputs ("\n\tMSA ASE", stdout);
13850   if (mask & AFL_ASE_MIPS16)
13851     fputs ("\n\tMIPS16 ASE", stdout);
13852   if (mask & AFL_ASE_MICROMIPS)
13853     fputs ("\n\tMICROMIPS ASE", stdout);
13854   if (mask & AFL_ASE_XPA)
13855     fputs ("\n\tXPA ASE", stdout);
13856   if (mask == 0)
13857     fprintf (stdout, "\n\t%s", _("None"));
13858   else if ((mask & ~AFL_ASE_MASK) != 0)
13859     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13860 }
13861
13862 static void
13863 print_mips_isa_ext (unsigned int isa_ext)
13864 {
13865   switch (isa_ext)
13866     {
13867     case 0:
13868       fputs (_("None"), stdout);
13869       break;
13870     case AFL_EXT_XLR:
13871       fputs ("RMI XLR", stdout);
13872       break;
13873     case AFL_EXT_OCTEON3:
13874       fputs ("Cavium Networks Octeon3", stdout);
13875       break;
13876     case AFL_EXT_OCTEON2:
13877       fputs ("Cavium Networks Octeon2", stdout);
13878       break;
13879     case AFL_EXT_OCTEONP:
13880       fputs ("Cavium Networks OcteonP", stdout);
13881       break;
13882     case AFL_EXT_LOONGSON_3A:
13883       fputs ("Loongson 3A", stdout);
13884       break;
13885     case AFL_EXT_OCTEON:
13886       fputs ("Cavium Networks Octeon", stdout);
13887       break;
13888     case AFL_EXT_5900:
13889       fputs ("Toshiba R5900", stdout);
13890       break;
13891     case AFL_EXT_4650:
13892       fputs ("MIPS R4650", stdout);
13893       break;
13894     case AFL_EXT_4010:
13895       fputs ("LSI R4010", stdout);
13896       break;
13897     case AFL_EXT_4100:
13898       fputs ("NEC VR4100", stdout);
13899       break;
13900     case AFL_EXT_3900:
13901       fputs ("Toshiba R3900", stdout);
13902       break;
13903     case AFL_EXT_10000:
13904       fputs ("MIPS R10000", stdout);
13905       break;
13906     case AFL_EXT_SB1:
13907       fputs ("Broadcom SB-1", stdout);
13908       break;
13909     case AFL_EXT_4111:
13910       fputs ("NEC VR4111/VR4181", stdout);
13911       break;
13912     case AFL_EXT_4120:
13913       fputs ("NEC VR4120", stdout);
13914       break;
13915     case AFL_EXT_5400:
13916       fputs ("NEC VR5400", stdout);
13917       break;
13918     case AFL_EXT_5500:
13919       fputs ("NEC VR5500", stdout);
13920       break;
13921     case AFL_EXT_LOONGSON_2E:
13922       fputs ("ST Microelectronics Loongson 2E", stdout);
13923       break;
13924     case AFL_EXT_LOONGSON_2F:
13925       fputs ("ST Microelectronics Loongson 2F", stdout);
13926       break;
13927     default:
13928       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13929     }
13930 }
13931
13932 static int
13933 get_mips_reg_size (int reg_size)
13934 {
13935   return (reg_size == AFL_REG_NONE) ? 0
13936          : (reg_size == AFL_REG_32) ? 32
13937          : (reg_size == AFL_REG_64) ? 64
13938          : (reg_size == AFL_REG_128) ? 128
13939          : -1;
13940 }
13941
13942 static int
13943 process_mips_specific (FILE * file)
13944 {
13945   Elf_Internal_Dyn * entry;
13946   Elf_Internal_Shdr *sect = NULL;
13947   size_t liblist_offset = 0;
13948   size_t liblistno = 0;
13949   size_t conflictsno = 0;
13950   size_t options_offset = 0;
13951   size_t conflicts_offset = 0;
13952   size_t pltrelsz = 0;
13953   size_t pltrel = 0;
13954   bfd_vma pltgot = 0;
13955   bfd_vma mips_pltgot = 0;
13956   bfd_vma jmprel = 0;
13957   bfd_vma local_gotno = 0;
13958   bfd_vma gotsym = 0;
13959   bfd_vma symtabno = 0;
13960
13961   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13962                       display_mips_gnu_attribute);
13963
13964   sect = find_section (".MIPS.abiflags");
13965
13966   if (sect != NULL)
13967     {
13968       Elf_External_ABIFlags_v0 *abiflags_ext;
13969       Elf_Internal_ABIFlags_v0 abiflags_in;
13970
13971       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13972         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13973       else
13974         {
13975           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13976                                    sect->sh_size, _("MIPS ABI Flags section"));
13977           if (abiflags_ext)
13978             {
13979               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13980               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13981               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13982               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13983               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13984               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13985               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13986               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13987               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13988               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13989               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13990
13991               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13992               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13993               if (abiflags_in.isa_rev > 1)
13994                 printf ("r%d", abiflags_in.isa_rev);
13995               printf ("\nGPR size: %d",
13996                       get_mips_reg_size (abiflags_in.gpr_size));
13997               printf ("\nCPR1 size: %d",
13998                       get_mips_reg_size (abiflags_in.cpr1_size));
13999               printf ("\nCPR2 size: %d",
14000                       get_mips_reg_size (abiflags_in.cpr2_size));
14001               fputs ("\nFP ABI: ", stdout);
14002               print_mips_fp_abi_value (abiflags_in.fp_abi);
14003               fputs ("ISA Extension: ", stdout);
14004               print_mips_isa_ext (abiflags_in.isa_ext);
14005               fputs ("\nASEs:", stdout);
14006               print_mips_ases (abiflags_in.ases);
14007               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14008               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14009               fputc ('\n', stdout);
14010               free (abiflags_ext);
14011             }
14012         }
14013     }
14014
14015   /* We have a lot of special sections.  Thanks SGI!  */
14016   if (dynamic_section == NULL)
14017     /* No information available.  */
14018     return 0;
14019
14020   for (entry = dynamic_section;
14021        /* PR 17531 file: 012-50589-0.004.  */
14022        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14023        ++entry)
14024     switch (entry->d_tag)
14025       {
14026       case DT_MIPS_LIBLIST:
14027         liblist_offset
14028           = offset_from_vma (file, entry->d_un.d_val,
14029                              liblistno * sizeof (Elf32_External_Lib));
14030         break;
14031       case DT_MIPS_LIBLISTNO:
14032         liblistno = entry->d_un.d_val;
14033         break;
14034       case DT_MIPS_OPTIONS:
14035         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14036         break;
14037       case DT_MIPS_CONFLICT:
14038         conflicts_offset
14039           = offset_from_vma (file, entry->d_un.d_val,
14040                              conflictsno * sizeof (Elf32_External_Conflict));
14041         break;
14042       case DT_MIPS_CONFLICTNO:
14043         conflictsno = entry->d_un.d_val;
14044         break;
14045       case DT_PLTGOT:
14046         pltgot = entry->d_un.d_ptr;
14047         break;
14048       case DT_MIPS_LOCAL_GOTNO:
14049         local_gotno = entry->d_un.d_val;
14050         break;
14051       case DT_MIPS_GOTSYM:
14052         gotsym = entry->d_un.d_val;
14053         break;
14054       case DT_MIPS_SYMTABNO:
14055         symtabno = entry->d_un.d_val;
14056         break;
14057       case DT_MIPS_PLTGOT:
14058         mips_pltgot = entry->d_un.d_ptr;
14059         break;
14060       case DT_PLTREL:
14061         pltrel = entry->d_un.d_val;
14062         break;
14063       case DT_PLTRELSZ:
14064         pltrelsz = entry->d_un.d_val;
14065         break;
14066       case DT_JMPREL:
14067         jmprel = entry->d_un.d_ptr;
14068         break;
14069       default:
14070         break;
14071       }
14072
14073   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14074     {
14075       Elf32_External_Lib * elib;
14076       size_t cnt;
14077
14078       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14079                                               liblistno,
14080                                               sizeof (Elf32_External_Lib),
14081                                               _("liblist section data"));
14082       if (elib)
14083         {
14084           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14085                   (unsigned long) liblistno);
14086           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14087                  stdout);
14088
14089           for (cnt = 0; cnt < liblistno; ++cnt)
14090             {
14091               Elf32_Lib liblist;
14092               time_t atime;
14093               char timebuf[20];
14094               struct tm * tmp;
14095
14096               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14097               atime = BYTE_GET (elib[cnt].l_time_stamp);
14098               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14099               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14100               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14101
14102               tmp = gmtime (&atime);
14103               snprintf (timebuf, sizeof (timebuf),
14104                         "%04u-%02u-%02uT%02u:%02u:%02u",
14105                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14106                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14107
14108               printf ("%3lu: ", (unsigned long) cnt);
14109               if (VALID_DYNAMIC_NAME (liblist.l_name))
14110                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14111               else
14112                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14113               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14114                       liblist.l_version);
14115
14116               if (liblist.l_flags == 0)
14117                 puts (_(" NONE"));
14118               else
14119                 {
14120                   static const struct
14121                   {
14122                     const char * name;
14123                     int bit;
14124                   }
14125                   l_flags_vals[] =
14126                   {
14127                     { " EXACT_MATCH", LL_EXACT_MATCH },
14128                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14129                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14130                     { " EXPORTS", LL_EXPORTS },
14131                     { " DELAY_LOAD", LL_DELAY_LOAD },
14132                     { " DELTA", LL_DELTA }
14133                   };
14134                   int flags = liblist.l_flags;
14135                   size_t fcnt;
14136
14137                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14138                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14139                       {
14140                         fputs (l_flags_vals[fcnt].name, stdout);
14141                         flags ^= l_flags_vals[fcnt].bit;
14142                       }
14143                   if (flags != 0)
14144                     printf (" %#x", (unsigned int) flags);
14145
14146                   puts ("");
14147                 }
14148             }
14149
14150           free (elib);
14151         }
14152     }
14153
14154   if (options_offset != 0)
14155     {
14156       Elf_External_Options * eopt;
14157       Elf_Internal_Options * iopt;
14158       Elf_Internal_Options * option;
14159       size_t offset;
14160       int cnt;
14161       sect = section_headers;
14162
14163       /* Find the section header so that we get the size.  */
14164       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14165       /* PR 17533 file: 012-277276-0.004.  */
14166       if (sect == NULL)
14167         {
14168           error (_("No MIPS_OPTIONS header found\n"));
14169           return 0;
14170         }
14171
14172       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14173                                                 sect->sh_size, _("options"));
14174       if (eopt)
14175         {
14176           iopt = (Elf_Internal_Options *)
14177               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14178           if (iopt == NULL)
14179             {
14180               error (_("Out of memory allocatinf space for MIPS options\n"));
14181               return 0;
14182             }
14183
14184           offset = cnt = 0;
14185           option = iopt;
14186
14187           while (offset <= sect->sh_size - sizeof (* eopt))
14188             {
14189               Elf_External_Options * eoption;
14190
14191               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14192
14193               option->kind = BYTE_GET (eoption->kind);
14194               option->size = BYTE_GET (eoption->size);
14195               option->section = BYTE_GET (eoption->section);
14196               option->info = BYTE_GET (eoption->info);
14197
14198               /* PR 17531: file: ffa0fa3b.  */
14199               if (option->size < sizeof (* eopt)
14200                   || offset + option->size > sect->sh_size)
14201                 {
14202                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14203                   return 0;
14204                 }
14205               offset += option->size;
14206
14207               ++option;
14208               ++cnt;
14209             }
14210
14211           printf (_("\nSection '%s' contains %d entries:\n"),
14212                   printable_section_name (sect), cnt);
14213
14214           option = iopt;
14215           offset = 0;
14216
14217           while (cnt-- > 0)
14218             {
14219               size_t len;
14220
14221               switch (option->kind)
14222                 {
14223                 case ODK_NULL:
14224                   /* This shouldn't happen.  */
14225                   printf (" NULL       %d %lx", option->section, option->info);
14226                   break;
14227                 case ODK_REGINFO:
14228                   printf (" REGINFO    ");
14229                   if (elf_header.e_machine == EM_MIPS)
14230                     {
14231                       /* 32bit form.  */
14232                       Elf32_External_RegInfo * ereg;
14233                       Elf32_RegInfo reginfo;
14234
14235                       ereg = (Elf32_External_RegInfo *) (option + 1);
14236                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14237                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14238                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14239                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14240                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14241                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14242
14243                       printf ("GPR %08lx  GP 0x%lx\n",
14244                               reginfo.ri_gprmask,
14245                               (unsigned long) reginfo.ri_gp_value);
14246                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14247                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14248                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14249                     }
14250                   else
14251                     {
14252                       /* 64 bit form.  */
14253                       Elf64_External_RegInfo * ereg;
14254                       Elf64_Internal_RegInfo reginfo;
14255
14256                       ereg = (Elf64_External_RegInfo *) (option + 1);
14257                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14258                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14259                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14260                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14261                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14262                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14263
14264                       printf ("GPR %08lx  GP 0x",
14265                               reginfo.ri_gprmask);
14266                       printf_vma (reginfo.ri_gp_value);
14267                       printf ("\n");
14268
14269                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14270                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14271                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14272                     }
14273                   ++option;
14274                   continue;
14275                 case ODK_EXCEPTIONS:
14276                   fputs (" EXCEPTIONS fpe_min(", stdout);
14277                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14278                   fputs (") fpe_max(", stdout);
14279                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14280                   fputs (")", stdout);
14281
14282                   if (option->info & OEX_PAGE0)
14283                     fputs (" PAGE0", stdout);
14284                   if (option->info & OEX_SMM)
14285                     fputs (" SMM", stdout);
14286                   if (option->info & OEX_FPDBUG)
14287                     fputs (" FPDBUG", stdout);
14288                   if (option->info & OEX_DISMISS)
14289                     fputs (" DISMISS", stdout);
14290                   break;
14291                 case ODK_PAD:
14292                   fputs (" PAD       ", stdout);
14293                   if (option->info & OPAD_PREFIX)
14294                     fputs (" PREFIX", stdout);
14295                   if (option->info & OPAD_POSTFIX)
14296                     fputs (" POSTFIX", stdout);
14297                   if (option->info & OPAD_SYMBOL)
14298                     fputs (" SYMBOL", stdout);
14299                   break;
14300                 case ODK_HWPATCH:
14301                   fputs (" HWPATCH   ", stdout);
14302                   if (option->info & OHW_R4KEOP)
14303                     fputs (" R4KEOP", stdout);
14304                   if (option->info & OHW_R8KPFETCH)
14305                     fputs (" R8KPFETCH", stdout);
14306                   if (option->info & OHW_R5KEOP)
14307                     fputs (" R5KEOP", stdout);
14308                   if (option->info & OHW_R5KCVTL)
14309                     fputs (" R5KCVTL", stdout);
14310                   break;
14311                 case ODK_FILL:
14312                   fputs (" FILL       ", stdout);
14313                   /* XXX Print content of info word?  */
14314                   break;
14315                 case ODK_TAGS:
14316                   fputs (" TAGS       ", stdout);
14317                   /* XXX Print content of info word?  */
14318                   break;
14319                 case ODK_HWAND:
14320                   fputs (" HWAND     ", stdout);
14321                   if (option->info & OHWA0_R4KEOP_CHECKED)
14322                     fputs (" R4KEOP_CHECKED", stdout);
14323                   if (option->info & OHWA0_R4KEOP_CLEAN)
14324                     fputs (" R4KEOP_CLEAN", stdout);
14325                   break;
14326                 case ODK_HWOR:
14327                   fputs (" HWOR      ", stdout);
14328                   if (option->info & OHWA0_R4KEOP_CHECKED)
14329                     fputs (" R4KEOP_CHECKED", stdout);
14330                   if (option->info & OHWA0_R4KEOP_CLEAN)
14331                     fputs (" R4KEOP_CLEAN", stdout);
14332                   break;
14333                 case ODK_GP_GROUP:
14334                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14335                           option->info & OGP_GROUP,
14336                           (option->info & OGP_SELF) >> 16);
14337                   break;
14338                 case ODK_IDENT:
14339                   printf (" IDENT     %#06lx  self-contained %#06lx",
14340                           option->info & OGP_GROUP,
14341                           (option->info & OGP_SELF) >> 16);
14342                   break;
14343                 default:
14344                   /* This shouldn't happen.  */
14345                   printf (" %3d ???     %d %lx",
14346                           option->kind, option->section, option->info);
14347                   break;
14348                 }
14349
14350               len = sizeof (* eopt);
14351               while (len < option->size)
14352                 {
14353                   char datum = * ((char *) eopt + offset + len);
14354
14355                   if (ISPRINT (datum))
14356                     printf ("%c", datum);
14357                   else
14358                     printf ("\\%03o", datum);
14359                   len ++;
14360                 }
14361               fputs ("\n", stdout);
14362
14363               offset += option->size;
14364               ++option;
14365             }
14366
14367           free (eopt);
14368         }
14369     }
14370
14371   if (conflicts_offset != 0 && conflictsno != 0)
14372     {
14373       Elf32_Conflict * iconf;
14374       size_t cnt;
14375
14376       if (dynamic_symbols == NULL)
14377         {
14378           error (_("conflict list found without a dynamic symbol table\n"));
14379           return 0;
14380         }
14381
14382       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14383       if (iconf == NULL)
14384         {
14385           error (_("Out of memory allocating space for dynamic conflicts\n"));
14386           return 0;
14387         }
14388
14389       if (is_32bit_elf)
14390         {
14391           Elf32_External_Conflict * econf32;
14392
14393           econf32 = (Elf32_External_Conflict *)
14394               get_data (NULL, file, conflicts_offset, conflictsno,
14395                         sizeof (* econf32), _("conflict"));
14396           if (!econf32)
14397             return 0;
14398
14399           for (cnt = 0; cnt < conflictsno; ++cnt)
14400             iconf[cnt] = BYTE_GET (econf32[cnt]);
14401
14402           free (econf32);
14403         }
14404       else
14405         {
14406           Elf64_External_Conflict * econf64;
14407
14408           econf64 = (Elf64_External_Conflict *)
14409               get_data (NULL, file, conflicts_offset, conflictsno,
14410                         sizeof (* econf64), _("conflict"));
14411           if (!econf64)
14412             return 0;
14413
14414           for (cnt = 0; cnt < conflictsno; ++cnt)
14415             iconf[cnt] = BYTE_GET (econf64[cnt]);
14416
14417           free (econf64);
14418         }
14419
14420       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14421               (unsigned long) conflictsno);
14422       puts (_("  Num:    Index       Value  Name"));
14423
14424       for (cnt = 0; cnt < conflictsno; ++cnt)
14425         {
14426           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14427
14428           if (iconf[cnt] >= num_dynamic_syms)
14429             printf (_("<corrupt symbol index>"));
14430           else
14431             {
14432               Elf_Internal_Sym * psym;
14433
14434               psym = & dynamic_symbols[iconf[cnt]];
14435               print_vma (psym->st_value, FULL_HEX);
14436               putchar (' ');
14437               if (VALID_DYNAMIC_NAME (psym->st_name))
14438                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14439               else
14440                 printf (_("<corrupt: %14ld>"), psym->st_name);
14441             }
14442           putchar ('\n');
14443         }
14444
14445       free (iconf);
14446     }
14447
14448   if (pltgot != 0 && local_gotno != 0)
14449     {
14450       bfd_vma ent, local_end, global_end;
14451       size_t i, offset;
14452       unsigned char * data;
14453       unsigned char * data_end;
14454       int addr_size;
14455
14456       ent = pltgot;
14457       addr_size = (is_32bit_elf ? 4 : 8);
14458       local_end = pltgot + local_gotno * addr_size;
14459
14460       /* PR binutils/17533 file: 012-111227-0.004  */
14461       if (symtabno < gotsym)
14462         {
14463           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14464                  (unsigned long) gotsym, (unsigned long) symtabno);
14465           return 0;
14466         }
14467
14468       global_end = local_end + (symtabno - gotsym) * addr_size;
14469       /* PR 17531: file: 54c91a34.  */
14470       if (global_end < local_end)
14471         {
14472           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14473           return 0;
14474         }
14475
14476       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14477       data = (unsigned char *) get_data (NULL, file, offset,
14478                                          global_end - pltgot, 1,
14479                                          _("Global Offset Table data"));
14480       if (data == NULL)
14481         return 0;
14482       data_end = data + (global_end - pltgot);
14483
14484       printf (_("\nPrimary GOT:\n"));
14485       printf (_(" Canonical gp value: "));
14486       print_vma (pltgot + 0x7ff0, LONG_HEX);
14487       printf ("\n\n");
14488
14489       printf (_(" Reserved entries:\n"));
14490       printf (_("  %*s %10s %*s Purpose\n"),
14491               addr_size * 2, _("Address"), _("Access"),
14492               addr_size * 2, _("Initial"));
14493       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14494       printf (_(" Lazy resolver\n"));
14495       if (ent == (bfd_vma) -1)
14496         goto got_print_fail;
14497       if (data
14498           && (byte_get (data + ent - pltgot, addr_size)
14499               >> (addr_size * 8 - 1)) != 0)
14500         {
14501           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14502           printf (_(" Module pointer (GNU extension)\n"));
14503           if (ent == (bfd_vma) -1)
14504             goto got_print_fail;
14505         }
14506       printf ("\n");
14507
14508       if (ent < local_end)
14509         {
14510           printf (_(" Local entries:\n"));
14511           printf ("  %*s %10s %*s\n",
14512                   addr_size * 2, _("Address"), _("Access"),
14513                   addr_size * 2, _("Initial"));
14514           while (ent < local_end)
14515             {
14516               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14517               printf ("\n");
14518               if (ent == (bfd_vma) -1)
14519                 goto got_print_fail;
14520             }
14521           printf ("\n");
14522         }
14523
14524       if (gotsym < symtabno)
14525         {
14526           int sym_width;
14527
14528           printf (_(" Global entries:\n"));
14529           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14530                   addr_size * 2, _("Address"),
14531                   _("Access"),
14532                   addr_size * 2, _("Initial"),
14533                   addr_size * 2, _("Sym.Val."),
14534                   _("Type"),
14535                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14536                   _("Ndx"), _("Name"));
14537
14538           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14539
14540           for (i = gotsym; i < symtabno; i++)
14541             {
14542               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14543               printf (" ");
14544
14545               if (dynamic_symbols == NULL)
14546                 printf (_("<no dynamic symbols>"));
14547               else if (i < num_dynamic_syms)
14548                 {
14549                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14550
14551                   print_vma (psym->st_value, LONG_HEX);
14552                   printf (" %-7s %3s ",
14553                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14554                           get_symbol_index_type (psym->st_shndx));
14555
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               else
14562                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14563                         (unsigned long) i);
14564
14565               printf ("\n");
14566               if (ent == (bfd_vma) -1)
14567                 break;
14568             }
14569           printf ("\n");
14570         }
14571
14572     got_print_fail:
14573       if (data)
14574         free (data);
14575     }
14576
14577   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14578     {
14579       bfd_vma ent, end;
14580       size_t offset, rel_offset;
14581       unsigned long count, i;
14582       unsigned char * data;
14583       int addr_size, sym_width;
14584       Elf_Internal_Rela * rels;
14585
14586       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14587       if (pltrel == DT_RELA)
14588         {
14589           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14590             return 0;
14591         }
14592       else
14593         {
14594           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14595             return 0;
14596         }
14597
14598       ent = mips_pltgot;
14599       addr_size = (is_32bit_elf ? 4 : 8);
14600       end = mips_pltgot + (2 + count) * addr_size;
14601
14602       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14603       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14604                                          1, _("Procedure Linkage Table data"));
14605       if (data == NULL)
14606         return 0;
14607
14608       printf ("\nPLT GOT:\n\n");
14609       printf (_(" Reserved entries:\n"));
14610       printf (_("  %*s %*s Purpose\n"),
14611               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14612       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14613       printf (_(" PLT lazy resolver\n"));
14614       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14615       printf (_(" Module pointer\n"));
14616       printf ("\n");
14617
14618       printf (_(" Entries:\n"));
14619       printf ("  %*s %*s %*s %-7s %3s %s\n",
14620               addr_size * 2, _("Address"),
14621               addr_size * 2, _("Initial"),
14622               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14623       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14624       for (i = 0; i < count; i++)
14625         {
14626           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14627
14628           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14629           printf (" ");
14630
14631           if (idx >= num_dynamic_syms)
14632             printf (_("<corrupt symbol index: %lu>"), idx);
14633           else
14634             {
14635               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14636
14637               print_vma (psym->st_value, LONG_HEX);
14638               printf (" %-7s %3s ",
14639                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14640                       get_symbol_index_type (psym->st_shndx));
14641               if (VALID_DYNAMIC_NAME (psym->st_name))
14642                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14643               else
14644                 printf (_("<corrupt: %14ld>"), psym->st_name);
14645             }
14646           printf ("\n");
14647         }
14648       printf ("\n");
14649
14650       if (data)
14651         free (data);
14652       free (rels);
14653     }
14654
14655   return 1;
14656 }
14657
14658 static int
14659 process_nds32_specific (FILE * file)
14660 {
14661   Elf_Internal_Shdr *sect = NULL;
14662
14663   sect = find_section (".nds32_e_flags");
14664   if (sect != NULL)
14665     {
14666       unsigned int *flag;
14667
14668       printf ("\nNDS32 elf flags section:\n");
14669       flag = get_data (NULL, file, sect->sh_offset, 1,
14670                        sect->sh_size, _("NDS32 elf flags section"));
14671
14672       switch ((*flag) & 0x3)
14673         {
14674         case 0:
14675           printf ("(VEC_SIZE):\tNo entry.\n");
14676           break;
14677         case 1:
14678           printf ("(VEC_SIZE):\t4 bytes\n");
14679           break;
14680         case 2:
14681           printf ("(VEC_SIZE):\t16 bytes\n");
14682           break;
14683         case 3:
14684           printf ("(VEC_SIZE):\treserved\n");
14685           break;
14686         }
14687     }
14688
14689   return TRUE;
14690 }
14691
14692 static int
14693 process_gnu_liblist (FILE * file)
14694 {
14695   Elf_Internal_Shdr * section;
14696   Elf_Internal_Shdr * string_sec;
14697   Elf32_External_Lib * elib;
14698   char * strtab;
14699   size_t strtab_size;
14700   size_t cnt;
14701   unsigned i;
14702
14703   if (! do_arch)
14704     return 0;
14705
14706   for (i = 0, section = section_headers;
14707        i < elf_header.e_shnum;
14708        i++, section++)
14709     {
14710       switch (section->sh_type)
14711         {
14712         case SHT_GNU_LIBLIST:
14713           if (section->sh_link >= elf_header.e_shnum)
14714             break;
14715
14716           elib = (Elf32_External_Lib *)
14717               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14718                         _("liblist section data"));
14719
14720           if (elib == NULL)
14721             break;
14722           string_sec = section_headers + section->sh_link;
14723
14724           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14725                                       string_sec->sh_size,
14726                                       _("liblist string table"));
14727           if (strtab == NULL
14728               || section->sh_entsize != sizeof (Elf32_External_Lib))
14729             {
14730               free (elib);
14731               free (strtab);
14732               break;
14733             }
14734           strtab_size = string_sec->sh_size;
14735
14736           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14737                   printable_section_name (section),
14738                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14739
14740           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14741
14742           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14743                ++cnt)
14744             {
14745               Elf32_Lib liblist;
14746               time_t atime;
14747               char timebuf[20];
14748               struct tm * tmp;
14749
14750               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14751               atime = BYTE_GET (elib[cnt].l_time_stamp);
14752               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14753               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14754               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14755
14756               tmp = gmtime (&atime);
14757               snprintf (timebuf, sizeof (timebuf),
14758                         "%04u-%02u-%02uT%02u:%02u:%02u",
14759                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14760                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14761
14762               printf ("%3lu: ", (unsigned long) cnt);
14763               if (do_wide)
14764                 printf ("%-20s", liblist.l_name < strtab_size
14765                         ? strtab + liblist.l_name : _("<corrupt>"));
14766               else
14767                 printf ("%-20.20s", liblist.l_name < strtab_size
14768                         ? strtab + liblist.l_name : _("<corrupt>"));
14769               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14770                       liblist.l_version, liblist.l_flags);
14771             }
14772
14773           free (elib);
14774           free (strtab);
14775         }
14776     }
14777
14778   return 1;
14779 }
14780
14781 static const char *
14782 get_note_type (unsigned e_type)
14783 {
14784   static char buff[64];
14785
14786   if (elf_header.e_type == ET_CORE)
14787     switch (e_type)
14788       {
14789       case NT_AUXV:
14790         return _("NT_AUXV (auxiliary vector)");
14791       case NT_PRSTATUS:
14792         return _("NT_PRSTATUS (prstatus structure)");
14793       case NT_FPREGSET:
14794         return _("NT_FPREGSET (floating point registers)");
14795       case NT_PRPSINFO:
14796         return _("NT_PRPSINFO (prpsinfo structure)");
14797       case NT_TASKSTRUCT:
14798         return _("NT_TASKSTRUCT (task structure)");
14799       case NT_PRXFPREG:
14800         return _("NT_PRXFPREG (user_xfpregs structure)");
14801       case NT_PPC_VMX:
14802         return _("NT_PPC_VMX (ppc Altivec registers)");
14803       case NT_PPC_VSX:
14804         return _("NT_PPC_VSX (ppc VSX registers)");
14805       case NT_386_TLS:
14806         return _("NT_386_TLS (x86 TLS information)");
14807       case NT_386_IOPERM:
14808         return _("NT_386_IOPERM (x86 I/O permissions)");
14809       case NT_X86_XSTATE:
14810         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14811       case NT_S390_HIGH_GPRS:
14812         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14813       case NT_S390_TIMER:
14814         return _("NT_S390_TIMER (s390 timer register)");
14815       case NT_S390_TODCMP:
14816         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14817       case NT_S390_TODPREG:
14818         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14819       case NT_S390_CTRS:
14820         return _("NT_S390_CTRS (s390 control registers)");
14821       case NT_S390_PREFIX:
14822         return _("NT_S390_PREFIX (s390 prefix register)");
14823       case NT_S390_LAST_BREAK:
14824         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14825       case NT_S390_SYSTEM_CALL:
14826         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14827       case NT_S390_TDB:
14828         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14829       case NT_S390_VXRS_LOW:
14830         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14831       case NT_S390_VXRS_HIGH:
14832         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14833       case NT_ARM_VFP:
14834         return _("NT_ARM_VFP (arm VFP registers)");
14835       case NT_ARM_TLS:
14836         return _("NT_ARM_TLS (AArch TLS registers)");
14837       case NT_ARM_HW_BREAK:
14838         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14839       case NT_ARM_HW_WATCH:
14840         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14841       case NT_PSTATUS:
14842         return _("NT_PSTATUS (pstatus structure)");
14843       case NT_FPREGS:
14844         return _("NT_FPREGS (floating point registers)");
14845       case NT_PSINFO:
14846         return _("NT_PSINFO (psinfo structure)");
14847       case NT_LWPSTATUS:
14848         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14849       case NT_LWPSINFO:
14850         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14851       case NT_WIN32PSTATUS:
14852         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14853       case NT_SIGINFO:
14854         return _("NT_SIGINFO (siginfo_t data)");
14855       case NT_FILE:
14856         return _("NT_FILE (mapped files)");
14857       default:
14858         break;
14859       }
14860   else
14861     switch (e_type)
14862       {
14863       case NT_VERSION:
14864         return _("NT_VERSION (version)");
14865       case NT_ARCH:
14866         return _("NT_ARCH (architecture)");
14867       default:
14868         break;
14869       }
14870
14871   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14872   return buff;
14873 }
14874
14875 static int
14876 print_core_note (Elf_Internal_Note *pnote)
14877 {
14878   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14879   bfd_vma count, page_size;
14880   unsigned char *descdata, *filenames, *descend;
14881
14882   if (pnote->type != NT_FILE)
14883     return 1;
14884
14885 #ifndef BFD64
14886   if (!is_32bit_elf)
14887     {
14888       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14889       /* Still "successful".  */
14890       return 1;
14891     }
14892 #endif
14893
14894   if (pnote->descsz < 2 * addr_size)
14895     {
14896       printf (_("    Malformed note - too short for header\n"));
14897       return 0;
14898     }
14899
14900   descdata = (unsigned char *) pnote->descdata;
14901   descend = descdata + pnote->descsz;
14902
14903   if (descdata[pnote->descsz - 1] != '\0')
14904     {
14905       printf (_("    Malformed note - does not end with \\0\n"));
14906       return 0;
14907     }
14908
14909   count = byte_get (descdata, addr_size);
14910   descdata += addr_size;
14911
14912   page_size = byte_get (descdata, addr_size);
14913   descdata += addr_size;
14914
14915   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14916     {
14917       printf (_("    Malformed note - too short for supplied file count\n"));
14918       return 0;
14919     }
14920
14921   printf (_("    Page size: "));
14922   print_vma (page_size, DEC);
14923   printf ("\n");
14924
14925   printf (_("    %*s%*s%*s\n"),
14926           (int) (2 + 2 * addr_size), _("Start"),
14927           (int) (4 + 2 * addr_size), _("End"),
14928           (int) (4 + 2 * addr_size), _("Page Offset"));
14929   filenames = descdata + count * 3 * addr_size;
14930   while (--count > 0)
14931     {
14932       bfd_vma start, end, file_ofs;
14933
14934       if (filenames == descend)
14935         {
14936           printf (_("    Malformed note - filenames end too early\n"));
14937           return 0;
14938         }
14939
14940       start = byte_get (descdata, addr_size);
14941       descdata += addr_size;
14942       end = byte_get (descdata, addr_size);
14943       descdata += addr_size;
14944       file_ofs = byte_get (descdata, addr_size);
14945       descdata += addr_size;
14946
14947       printf ("    ");
14948       print_vma (start, FULL_HEX);
14949       printf ("  ");
14950       print_vma (end, FULL_HEX);
14951       printf ("  ");
14952       print_vma (file_ofs, FULL_HEX);
14953       printf ("\n        %s\n", filenames);
14954
14955       filenames += 1 + strlen ((char *) filenames);
14956     }
14957
14958   return 1;
14959 }
14960
14961 static const char *
14962 get_gnu_elf_note_type (unsigned e_type)
14963 {
14964   static char buff[64];
14965
14966   switch (e_type)
14967     {
14968     case NT_GNU_ABI_TAG:
14969       return _("NT_GNU_ABI_TAG (ABI version tag)");
14970     case NT_GNU_HWCAP:
14971       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14972     case NT_GNU_BUILD_ID:
14973       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14974     case NT_GNU_GOLD_VERSION:
14975       return _("NT_GNU_GOLD_VERSION (gold version)");
14976     default:
14977       break;
14978     }
14979
14980   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14981   return buff;
14982 }
14983
14984 static int
14985 print_gnu_note (Elf_Internal_Note *pnote)
14986 {
14987   switch (pnote->type)
14988     {
14989     case NT_GNU_BUILD_ID:
14990       {
14991         unsigned long i;
14992
14993         printf (_("    Build ID: "));
14994         for (i = 0; i < pnote->descsz; ++i)
14995           printf ("%02x", pnote->descdata[i] & 0xff);
14996         printf ("\n");
14997       }
14998       break;
14999
15000     case NT_GNU_ABI_TAG:
15001       {
15002         unsigned long os, major, minor, subminor;
15003         const char *osname;
15004
15005         /* PR 17531: file: 030-599401-0.004.  */
15006         if (pnote->descsz < 16)
15007           {
15008             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15009             break;
15010           }
15011
15012         os = byte_get ((unsigned char *) pnote->descdata, 4);
15013         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15014         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15015         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15016
15017         switch (os)
15018           {
15019           case GNU_ABI_TAG_LINUX:
15020             osname = "Linux";
15021             break;
15022           case GNU_ABI_TAG_HURD:
15023             osname = "Hurd";
15024             break;
15025           case GNU_ABI_TAG_SOLARIS:
15026             osname = "Solaris";
15027             break;
15028           case GNU_ABI_TAG_FREEBSD:
15029             osname = "FreeBSD";
15030             break;
15031           case GNU_ABI_TAG_NETBSD:
15032             osname = "NetBSD";
15033             break;
15034           default:
15035             osname = "Unknown";
15036             break;
15037           }
15038
15039         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15040                 major, minor, subminor);
15041       }
15042       break;
15043
15044     case NT_GNU_GOLD_VERSION:
15045       {
15046         unsigned long i;
15047
15048         printf (_("    Version: "));
15049         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15050           printf ("%c", pnote->descdata[i]);
15051         printf ("\n");
15052       }
15053       break;
15054     }
15055
15056   return 1;
15057 }
15058
15059 static const char *
15060 get_v850_elf_note_type (enum v850_notes n_type)
15061 {
15062   static char buff[64];
15063
15064   switch (n_type)
15065     {
15066     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15067     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15068     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15069     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15070     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15071     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15072     default:
15073       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15074       return buff;
15075     }
15076 }
15077
15078 static int
15079 print_v850_note (Elf_Internal_Note * pnote)
15080 {
15081   unsigned int val;
15082
15083   if (pnote->descsz != 4)
15084     return 0;
15085   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15086
15087   if (val == 0)
15088     {
15089       printf (_("not set\n"));
15090       return 1;
15091     }
15092
15093   switch (pnote->type)
15094     {
15095     case V850_NOTE_ALIGNMENT:
15096       switch (val)
15097         {
15098         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15099         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15100         }
15101       break;
15102
15103     case V850_NOTE_DATA_SIZE:
15104       switch (val)
15105         {
15106         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15107         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15108         }
15109       break;
15110
15111     case V850_NOTE_FPU_INFO:
15112       switch (val)
15113         {
15114         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15115         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15116         }
15117       break;
15118
15119     case V850_NOTE_MMU_INFO:
15120     case V850_NOTE_CACHE_INFO:
15121     case V850_NOTE_SIMD_INFO:
15122       if (val == EF_RH850_SIMD)
15123         {
15124           printf (_("yes\n"));
15125           return 1;
15126         }
15127       break;
15128
15129     default:
15130       /* An 'unknown note type' message will already have been displayed.  */
15131       break;
15132     }
15133
15134   printf (_("unknown value: %x\n"), val);
15135   return 0;
15136 }
15137
15138 static const char *
15139 get_netbsd_elfcore_note_type (unsigned e_type)
15140 {
15141   static char buff[64];
15142
15143   if (e_type == NT_NETBSDCORE_PROCINFO)
15144     {
15145       /* NetBSD core "procinfo" structure.  */
15146       return _("NetBSD procinfo structure");
15147     }
15148
15149   /* As of Jan 2002 there are no other machine-independent notes
15150      defined for NetBSD core files.  If the note type is less
15151      than the start of the machine-dependent note types, we don't
15152      understand it.  */
15153
15154   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15155     {
15156       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15157       return buff;
15158     }
15159
15160   switch (elf_header.e_machine)
15161     {
15162     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15163        and PT_GETFPREGS == mach+2.  */
15164
15165     case EM_OLD_ALPHA:
15166     case EM_ALPHA:
15167     case EM_SPARC:
15168     case EM_SPARC32PLUS:
15169     case EM_SPARCV9:
15170       switch (e_type)
15171         {
15172         case NT_NETBSDCORE_FIRSTMACH + 0:
15173           return _("PT_GETREGS (reg structure)");
15174         case NT_NETBSDCORE_FIRSTMACH + 2:
15175           return _("PT_GETFPREGS (fpreg structure)");
15176         default:
15177           break;
15178         }
15179       break;
15180
15181     /* On all other arch's, PT_GETREGS == mach+1 and
15182        PT_GETFPREGS == mach+3.  */
15183     default:
15184       switch (e_type)
15185         {
15186         case NT_NETBSDCORE_FIRSTMACH + 1:
15187           return _("PT_GETREGS (reg structure)");
15188         case NT_NETBSDCORE_FIRSTMACH + 3:
15189           return _("PT_GETFPREGS (fpreg structure)");
15190         default:
15191           break;
15192         }
15193     }
15194
15195   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15196             e_type - NT_NETBSDCORE_FIRSTMACH);
15197   return buff;
15198 }
15199
15200 static const char *
15201 get_stapsdt_note_type (unsigned e_type)
15202 {
15203   static char buff[64];
15204
15205   switch (e_type)
15206     {
15207     case NT_STAPSDT:
15208       return _("NT_STAPSDT (SystemTap probe descriptors)");
15209
15210     default:
15211       break;
15212     }
15213
15214   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15215   return buff;
15216 }
15217
15218 static int
15219 print_stapsdt_note (Elf_Internal_Note *pnote)
15220 {
15221   int addr_size = is_32bit_elf ? 4 : 8;
15222   char *data = pnote->descdata;
15223   char *data_end = pnote->descdata + pnote->descsz;
15224   bfd_vma pc, base_addr, semaphore;
15225   char *provider, *probe, *arg_fmt;
15226
15227   pc = byte_get ((unsigned char *) data, addr_size);
15228   data += addr_size;
15229   base_addr = byte_get ((unsigned char *) data, addr_size);
15230   data += addr_size;
15231   semaphore = byte_get ((unsigned char *) data, addr_size);
15232   data += addr_size;
15233
15234   provider = data;
15235   data += strlen (data) + 1;
15236   probe = data;
15237   data += strlen (data) + 1;
15238   arg_fmt = data;
15239   data += strlen (data) + 1;
15240
15241   printf (_("    Provider: %s\n"), provider);
15242   printf (_("    Name: %s\n"), probe);
15243   printf (_("    Location: "));
15244   print_vma (pc, FULL_HEX);
15245   printf (_(", Base: "));
15246   print_vma (base_addr, FULL_HEX);
15247   printf (_(", Semaphore: "));
15248   print_vma (semaphore, FULL_HEX);
15249   printf ("\n");
15250   printf (_("    Arguments: %s\n"), arg_fmt);
15251
15252   return data == data_end;
15253 }
15254
15255 static const char *
15256 get_ia64_vms_note_type (unsigned e_type)
15257 {
15258   static char buff[64];
15259
15260   switch (e_type)
15261     {
15262     case NT_VMS_MHD:
15263       return _("NT_VMS_MHD (module header)");
15264     case NT_VMS_LNM:
15265       return _("NT_VMS_LNM (language name)");
15266     case NT_VMS_SRC:
15267       return _("NT_VMS_SRC (source files)");
15268     case NT_VMS_TITLE:
15269       return "NT_VMS_TITLE";
15270     case NT_VMS_EIDC:
15271       return _("NT_VMS_EIDC (consistency check)");
15272     case NT_VMS_FPMODE:
15273       return _("NT_VMS_FPMODE (FP mode)");
15274     case NT_VMS_LINKTIME:
15275       return "NT_VMS_LINKTIME";
15276     case NT_VMS_IMGNAM:
15277       return _("NT_VMS_IMGNAM (image name)");
15278     case NT_VMS_IMGID:
15279       return _("NT_VMS_IMGID (image id)");
15280     case NT_VMS_LINKID:
15281       return _("NT_VMS_LINKID (link id)");
15282     case NT_VMS_IMGBID:
15283       return _("NT_VMS_IMGBID (build id)");
15284     case NT_VMS_GSTNAM:
15285       return _("NT_VMS_GSTNAM (sym table name)");
15286     case NT_VMS_ORIG_DYN:
15287       return "NT_VMS_ORIG_DYN";
15288     case NT_VMS_PATCHTIME:
15289       return "NT_VMS_PATCHTIME";
15290     default:
15291       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15292       return buff;
15293     }
15294 }
15295
15296 static int
15297 print_ia64_vms_note (Elf_Internal_Note * pnote)
15298 {
15299   switch (pnote->type)
15300     {
15301     case NT_VMS_MHD:
15302       if (pnote->descsz > 36)
15303         {
15304           size_t l = strlen (pnote->descdata + 34);
15305           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15306           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15307           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15308           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15309         }
15310       else
15311         printf (_("    Invalid size\n"));
15312       break;
15313     case NT_VMS_LNM:
15314       printf (_("   Language: %s\n"), pnote->descdata);
15315       break;
15316 #ifdef BFD64
15317     case NT_VMS_FPMODE:
15318       printf (_("   Floating Point mode: "));
15319       printf ("0x%016" BFD_VMA_FMT "x\n",
15320               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15321       break;
15322     case NT_VMS_LINKTIME:
15323       printf (_("   Link time: "));
15324       print_vms_time
15325         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15326       printf ("\n");
15327       break;
15328     case NT_VMS_PATCHTIME:
15329       printf (_("   Patch time: "));
15330       print_vms_time
15331         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15332       printf ("\n");
15333       break;
15334     case NT_VMS_ORIG_DYN:
15335       printf (_("   Major id: %u,  minor id: %u\n"),
15336               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15337               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15338       printf (_("   Last modified  : "));
15339       print_vms_time
15340         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15341       printf (_("\n   Link flags  : "));
15342       printf ("0x%016" BFD_VMA_FMT "x\n",
15343               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15344       printf (_("   Header flags: 0x%08x\n"),
15345               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15346       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15347       break;
15348 #endif
15349     case NT_VMS_IMGNAM:
15350       printf (_("    Image name: %s\n"), pnote->descdata);
15351       break;
15352     case NT_VMS_GSTNAM:
15353       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15354       break;
15355     case NT_VMS_IMGID:
15356       printf (_("    Image id: %s\n"), pnote->descdata);
15357       break;
15358     case NT_VMS_LINKID:
15359       printf (_("    Linker id: %s\n"), pnote->descdata);
15360       break;
15361     default:
15362       break;
15363     }
15364   return 1;
15365 }
15366
15367 /* Note that by the ELF standard, the name field is already null byte
15368    terminated, and namesz includes the terminating null byte.
15369    I.E. the value of namesz for the name "FSF" is 4.
15370
15371    If the value of namesz is zero, there is no name present.  */
15372 static int
15373 process_note (Elf_Internal_Note * pnote)
15374 {
15375   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15376   const char * nt;
15377
15378   if (pnote->namesz == 0)
15379     /* If there is no note name, then use the default set of
15380        note type strings.  */
15381     nt = get_note_type (pnote->type);
15382
15383   else if (const_strneq (pnote->namedata, "GNU"))
15384     /* GNU-specific object file notes.  */
15385     nt = get_gnu_elf_note_type (pnote->type);
15386
15387   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15388     /* NetBSD-specific core file notes.  */
15389     nt = get_netbsd_elfcore_note_type (pnote->type);
15390
15391   else if (strneq (pnote->namedata, "SPU/", 4))
15392     {
15393       /* SPU-specific core file notes.  */
15394       nt = pnote->namedata + 4;
15395       name = "SPU";
15396     }
15397
15398   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15399     /* VMS/ia64-specific file notes.  */
15400     nt = get_ia64_vms_note_type (pnote->type);
15401
15402   else if (const_strneq (pnote->namedata, "stapsdt"))
15403     nt = get_stapsdt_note_type (pnote->type);
15404
15405   else
15406     /* Don't recognize this note name; just use the default set of
15407        note type strings.  */
15408     nt = get_note_type (pnote->type);
15409
15410   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15411
15412   if (const_strneq (pnote->namedata, "IPF/VMS"))
15413     return print_ia64_vms_note (pnote);
15414   else if (const_strneq (pnote->namedata, "GNU"))
15415     return print_gnu_note (pnote);
15416   else if (const_strneq (pnote->namedata, "stapsdt"))
15417     return print_stapsdt_note (pnote);
15418   else if (const_strneq (pnote->namedata, "CORE"))
15419     return print_core_note (pnote);
15420   else
15421     return 1;
15422 }
15423
15424
15425 static int
15426 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15427 {
15428   Elf_External_Note * pnotes;
15429   Elf_External_Note * external;
15430   char * end;
15431   int res = 1;
15432
15433   if (length <= 0)
15434     return 0;
15435
15436   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15437                                            _("notes"));
15438   if (pnotes == NULL)
15439     return 0;
15440
15441   external = pnotes;
15442
15443   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15444           (unsigned long) offset, (unsigned long) length);
15445   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15446
15447   end = (char *) pnotes + length;
15448   while ((char *) external < end)
15449     {
15450       Elf_Internal_Note inote;
15451       size_t min_notesz;
15452       char *next;
15453       char * temp = NULL;
15454       size_t data_remaining = end - (char *) external;
15455
15456       if (!is_ia64_vms ())
15457         {
15458           /* PR binutils/15191
15459              Make sure that there is enough data to read.  */
15460           min_notesz = offsetof (Elf_External_Note, name);
15461           if (data_remaining < min_notesz)
15462             {
15463               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15464                     (int) data_remaining);
15465               break;
15466             }
15467           inote.type     = BYTE_GET (external->type);
15468           inote.namesz   = BYTE_GET (external->namesz);
15469           inote.namedata = external->name;
15470           inote.descsz   = BYTE_GET (external->descsz);
15471           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15472           /* PR 17531: file: 3443835e.  */
15473           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15474             {
15475               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15476               inote.descdata = inote.namedata;
15477               inote.namesz   = 0;
15478             }
15479
15480           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15481           next = inote.descdata + align_power (inote.descsz, 2);
15482         }
15483       else
15484         {
15485           Elf64_External_VMS_Note *vms_external;
15486
15487           /* PR binutils/15191
15488              Make sure that there is enough data to read.  */
15489           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15490           if (data_remaining < min_notesz)
15491             {
15492               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15493                     (int) data_remaining);
15494               break;
15495             }
15496
15497           vms_external = (Elf64_External_VMS_Note *) external;
15498           inote.type     = BYTE_GET (vms_external->type);
15499           inote.namesz   = BYTE_GET (vms_external->namesz);
15500           inote.namedata = vms_external->name;
15501           inote.descsz   = BYTE_GET (vms_external->descsz);
15502           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15503           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15504           next = inote.descdata + align_power (inote.descsz, 3);
15505         }
15506
15507       if (inote.descdata < (char *) external + min_notesz
15508           || next < (char *) external + min_notesz
15509           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15510           || inote.namedata + inote.namesz < inote.namedata
15511           || inote.descdata + inote.descsz < inote.descdata
15512           || data_remaining < (size_t)(next - (char *) external))
15513         {
15514           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15515                 (unsigned long) ((char *) external - (char *) pnotes));
15516           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15517                 inote.type, inote.namesz, inote.descsz);
15518           break;
15519         }
15520
15521       external = (Elf_External_Note *) next;
15522
15523       /* Verify that name is null terminated.  It appears that at least
15524          one version of Linux (RedHat 6.0) generates corefiles that don't
15525          comply with the ELF spec by failing to include the null byte in
15526          namesz.  */
15527       if (inote.namedata[inote.namesz - 1] != '\0')
15528         {
15529           temp = (char *) malloc (inote.namesz + 1);
15530           if (temp == NULL)
15531             {
15532               error (_("Out of memory allocating space for inote name\n"));
15533               res = 0;
15534               break;
15535             }
15536
15537           strncpy (temp, inote.namedata, inote.namesz);
15538           temp[inote.namesz] = 0;
15539
15540           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15541           inote.namedata = temp;
15542         }
15543
15544       res &= process_note (& inote);
15545
15546       if (temp != NULL)
15547         {
15548           free (temp);
15549           temp = NULL;
15550         }
15551     }
15552
15553   free (pnotes);
15554
15555   return res;
15556 }
15557
15558 static int
15559 process_corefile_note_segments (FILE * file)
15560 {
15561   Elf_Internal_Phdr * segment;
15562   unsigned int i;
15563   int res = 1;
15564
15565   if (! get_program_headers (file))
15566       return 0;
15567
15568   for (i = 0, segment = program_headers;
15569        i < elf_header.e_phnum;
15570        i++, segment++)
15571     {
15572       if (segment->p_type == PT_NOTE)
15573         res &= process_corefile_note_segment (file,
15574                                               (bfd_vma) segment->p_offset,
15575                                               (bfd_vma) segment->p_filesz);
15576     }
15577
15578   return res;
15579 }
15580
15581 static int
15582 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15583 {
15584   Elf_External_Note * pnotes;
15585   Elf_External_Note * external;
15586   char * end;
15587   int res = 1;
15588
15589   if (length <= 0)
15590     return 0;
15591
15592   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15593                                            _("v850 notes"));
15594   if (pnotes == NULL)
15595     return 0;
15596
15597   external = pnotes;
15598   end = (char*) pnotes + length;
15599
15600   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15601           (unsigned long) offset, (unsigned long) length);
15602
15603   while ((char *) external + sizeof (Elf_External_Note) < end)
15604     {
15605       Elf_External_Note * next;
15606       Elf_Internal_Note inote;
15607
15608       inote.type     = BYTE_GET (external->type);
15609       inote.namesz   = BYTE_GET (external->namesz);
15610       inote.namedata = external->name;
15611       inote.descsz   = BYTE_GET (external->descsz);
15612       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15613       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15614
15615       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15616         {
15617           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15618           inote.descdata = inote.namedata;
15619           inote.namesz   = 0;
15620         }
15621
15622       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15623
15624       if (   ((char *) next > end)
15625           || ((char *) next <  (char *) pnotes))
15626         {
15627           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15628                 (unsigned long) ((char *) external - (char *) pnotes));
15629           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15630                 inote.type, inote.namesz, inote.descsz);
15631           break;
15632         }
15633
15634       external = next;
15635
15636       /* Prevent out-of-bounds indexing.  */
15637       if (   inote.namedata + inote.namesz > end
15638           || inote.namedata + inote.namesz < inote.namedata)
15639         {
15640           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15641                 (unsigned long) ((char *) external - (char *) pnotes));
15642           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15643                 inote.type, inote.namesz, inote.descsz);
15644           break;
15645         }
15646
15647       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15648
15649       if (! print_v850_note (& inote))
15650         {
15651           res = 0;
15652           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15653                   inote.namesz, inote.descsz);
15654         }
15655     }
15656
15657   free (pnotes);
15658
15659   return res;
15660 }
15661
15662 static int
15663 process_note_sections (FILE * file)
15664 {
15665   Elf_Internal_Shdr * section;
15666   unsigned long i;
15667   int n = 0;
15668   int res = 1;
15669
15670   for (i = 0, section = section_headers;
15671        i < elf_header.e_shnum && section != NULL;
15672        i++, section++)
15673     {
15674       if (section->sh_type == SHT_NOTE)
15675         {
15676           res &= process_corefile_note_segment (file,
15677                                                 (bfd_vma) section->sh_offset,
15678                                                 (bfd_vma) section->sh_size);
15679           n++;
15680         }
15681
15682       if ((   elf_header.e_machine == EM_V800
15683            || elf_header.e_machine == EM_V850
15684            || elf_header.e_machine == EM_CYGNUS_V850)
15685           && section->sh_type == SHT_RENESAS_INFO)
15686         {
15687           res &= process_v850_notes (file,
15688                                      (bfd_vma) section->sh_offset,
15689                                      (bfd_vma) section->sh_size);
15690           n++;
15691         }
15692     }
15693
15694   if (n == 0)
15695     /* Try processing NOTE segments instead.  */
15696     return process_corefile_note_segments (file);
15697
15698   return res;
15699 }
15700
15701 static int
15702 process_notes (FILE * file)
15703 {
15704   /* If we have not been asked to display the notes then do nothing.  */
15705   if (! do_notes)
15706     return 1;
15707
15708   if (elf_header.e_type != ET_CORE)
15709     return process_note_sections (file);
15710
15711   /* No program headers means no NOTE segment.  */
15712   if (elf_header.e_phnum > 0)
15713     return process_corefile_note_segments (file);
15714
15715   printf (_("No note segments present in the core file.\n"));
15716   return 1;
15717 }
15718
15719 static int
15720 process_arch_specific (FILE * file)
15721 {
15722   if (! do_arch)
15723     return 1;
15724
15725   switch (elf_header.e_machine)
15726     {
15727     case EM_ARM:
15728       return process_arm_specific (file);
15729     case EM_MIPS:
15730     case EM_MIPS_RS3_LE:
15731       return process_mips_specific (file);
15732       break;
15733     case EM_NDS32:
15734       return process_nds32_specific (file);
15735       break;
15736     case EM_PPC:
15737       return process_power_specific (file);
15738       break;
15739     case EM_S390:
15740     case EM_S390_OLD:
15741       return process_s390_specific (file);
15742       break;
15743     case EM_SPARC:
15744     case EM_SPARC32PLUS:
15745     case EM_SPARCV9:
15746       return process_sparc_specific (file);
15747       break;
15748     case EM_TI_C6000:
15749       return process_tic6x_specific (file);
15750       break;
15751     case EM_MSP430:
15752       return process_msp430x_specific (file);
15753     default:
15754       break;
15755     }
15756   return 1;
15757 }
15758
15759 static int
15760 get_file_header (FILE * file)
15761 {
15762   /* Read in the identity array.  */
15763   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15764     return 0;
15765
15766   /* Determine how to read the rest of the header.  */
15767   switch (elf_header.e_ident[EI_DATA])
15768     {
15769     default: /* fall through */
15770     case ELFDATANONE: /* fall through */
15771     case ELFDATA2LSB:
15772       byte_get = byte_get_little_endian;
15773       byte_put = byte_put_little_endian;
15774       break;
15775     case ELFDATA2MSB:
15776       byte_get = byte_get_big_endian;
15777       byte_put = byte_put_big_endian;
15778       break;
15779     }
15780
15781   /* For now we only support 32 bit and 64 bit ELF files.  */
15782   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15783
15784   /* Read in the rest of the header.  */
15785   if (is_32bit_elf)
15786     {
15787       Elf32_External_Ehdr ehdr32;
15788
15789       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15790         return 0;
15791
15792       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15793       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15794       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15795       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15796       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15797       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15798       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15799       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15800       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15801       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15802       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15803       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15804       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15805     }
15806   else
15807     {
15808       Elf64_External_Ehdr ehdr64;
15809
15810       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15811          we will not be able to cope with the 64bit data found in
15812          64 ELF files.  Detect this now and abort before we start
15813          overwriting things.  */
15814       if (sizeof (bfd_vma) < 8)
15815         {
15816           error (_("This instance of readelf has been built without support for a\n\
15817 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15818           return 0;
15819         }
15820
15821       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15822         return 0;
15823
15824       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15825       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15826       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15827       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15828       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15829       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15830       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15831       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15832       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15833       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15834       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15835       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15836       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15837     }
15838
15839   if (elf_header.e_shoff)
15840     {
15841       /* There may be some extensions in the first section header.  Don't
15842          bomb if we can't read it.  */
15843       if (is_32bit_elf)
15844         get_32bit_section_headers (file, TRUE);
15845       else
15846         get_64bit_section_headers (file, TRUE);
15847     }
15848
15849   return 1;
15850 }
15851
15852 /* Process one ELF object file according to the command line options.
15853    This file may actually be stored in an archive.  The file is
15854    positioned at the start of the ELF object.  */
15855
15856 static int
15857 process_object (char * file_name, FILE * file)
15858 {
15859   unsigned int i;
15860
15861   if (! get_file_header (file))
15862     {
15863       error (_("%s: Failed to read file header\n"), file_name);
15864       return 1;
15865     }
15866
15867   /* Initialise per file variables.  */
15868   for (i = ARRAY_SIZE (version_info); i--;)
15869     version_info[i] = 0;
15870
15871   for (i = ARRAY_SIZE (dynamic_info); i--;)
15872     dynamic_info[i] = 0;
15873   dynamic_info_DT_GNU_HASH = 0;
15874
15875   /* Process the file.  */
15876   if (show_name)
15877     printf (_("\nFile: %s\n"), file_name);
15878
15879   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15880      Note we do this even if cmdline_dump_sects is empty because we
15881      must make sure that the dump_sets array is zeroed out before each
15882      object file is processed.  */
15883   if (num_dump_sects > num_cmdline_dump_sects)
15884     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15885
15886   if (num_cmdline_dump_sects > 0)
15887     {
15888       if (num_dump_sects == 0)
15889         /* A sneaky way of allocating the dump_sects array.  */
15890         request_dump_bynumber (num_cmdline_dump_sects, 0);
15891
15892       assert (num_dump_sects >= num_cmdline_dump_sects);
15893       memcpy (dump_sects, cmdline_dump_sects,
15894               num_cmdline_dump_sects * sizeof (* dump_sects));
15895     }
15896
15897   if (! process_file_header ())
15898     return 1;
15899
15900   if (! process_section_headers (file))
15901     {
15902       /* Without loaded section headers we cannot process lots of
15903          things.  */
15904       do_unwind = do_version = do_dump = do_arch = 0;
15905
15906       if (! do_using_dynamic)
15907         do_syms = do_dyn_syms = do_reloc = 0;
15908     }
15909
15910   if (! process_section_groups (file))
15911     {
15912       /* Without loaded section groups we cannot process unwind.  */
15913       do_unwind = 0;
15914     }
15915
15916   if (process_program_headers (file))
15917     process_dynamic_section (file);
15918
15919   process_relocs (file);
15920
15921   process_unwind (file);
15922
15923   process_symbol_table (file);
15924
15925   process_syminfo (file);
15926
15927   process_version_sections (file);
15928
15929   process_section_contents (file);
15930
15931   process_notes (file);
15932
15933   process_gnu_liblist (file);
15934
15935   process_arch_specific (file);
15936
15937   if (program_headers)
15938     {
15939       free (program_headers);
15940       program_headers = NULL;
15941     }
15942
15943   if (section_headers)
15944     {
15945       free (section_headers);
15946       section_headers = NULL;
15947     }
15948
15949   if (string_table)
15950     {
15951       free (string_table);
15952       string_table = NULL;
15953       string_table_length = 0;
15954     }
15955
15956   if (dynamic_strings)
15957     {
15958       free (dynamic_strings);
15959       dynamic_strings = NULL;
15960       dynamic_strings_length = 0;
15961     }
15962
15963   if (dynamic_symbols)
15964     {
15965       free (dynamic_symbols);
15966       dynamic_symbols = NULL;
15967       num_dynamic_syms = 0;
15968     }
15969
15970   if (dynamic_syminfo)
15971     {
15972       free (dynamic_syminfo);
15973       dynamic_syminfo = NULL;
15974     }
15975
15976   if (dynamic_section)
15977     {
15978       free (dynamic_section);
15979       dynamic_section = NULL;
15980     }
15981
15982   if (section_headers_groups)
15983     {
15984       free (section_headers_groups);
15985       section_headers_groups = NULL;
15986     }
15987
15988   if (section_groups)
15989     {
15990       struct group_list * g;
15991       struct group_list * next;
15992
15993       for (i = 0; i < group_count; i++)
15994         {
15995           for (g = section_groups [i].root; g != NULL; g = next)
15996             {
15997               next = g->next;
15998               free (g);
15999             }
16000         }
16001
16002       free (section_groups);
16003       section_groups = NULL;
16004     }
16005
16006   free_debug_memory ();
16007
16008   return 0;
16009 }
16010
16011 /* Process an ELF archive.
16012    On entry the file is positioned just after the ARMAG string.  */
16013
16014 static int
16015 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16016 {
16017   struct archive_info arch;
16018   struct archive_info nested_arch;
16019   size_t got;
16020   int ret;
16021
16022   show_name = 1;
16023
16024   /* The ARCH structure is used to hold information about this archive.  */
16025   arch.file_name = NULL;
16026   arch.file = NULL;
16027   arch.index_array = NULL;
16028   arch.sym_table = NULL;
16029   arch.longnames = NULL;
16030
16031   /* The NESTED_ARCH structure is used as a single-item cache of information
16032      about a nested archive (when members of a thin archive reside within
16033      another regular archive file).  */
16034   nested_arch.file_name = NULL;
16035   nested_arch.file = NULL;
16036   nested_arch.index_array = NULL;
16037   nested_arch.sym_table = NULL;
16038   nested_arch.longnames = NULL;
16039
16040   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16041     {
16042       ret = 1;
16043       goto out;
16044     }
16045
16046   if (do_archive_index)
16047     {
16048       if (arch.sym_table == NULL)
16049         error (_("%s: unable to dump the index as none was found\n"), file_name);
16050       else
16051         {
16052           unsigned long i, l;
16053           unsigned long current_pos;
16054
16055           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16056                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16057           current_pos = ftell (file);
16058
16059           for (i = l = 0; i < arch.index_num; i++)
16060             {
16061               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16062                 {
16063                   char * member_name;
16064
16065                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16066
16067                   if (member_name != NULL)
16068                     {
16069                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16070
16071                       if (qualified_name != NULL)
16072                         {
16073                           printf (_("Contents of binary %s at offset "), qualified_name);
16074                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16075                           putchar ('\n');
16076                           free (qualified_name);
16077                         }
16078                     }
16079                 }
16080
16081               if (l >= arch.sym_size)
16082                 {
16083                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16084                          file_name);
16085                   break;
16086                 }
16087               /* PR 17531: file: 0b6630b2.  */
16088               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16089               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16090             }
16091
16092           if (arch.uses_64bit_indicies)
16093             l = (l + 7) & ~ 7;
16094           else
16095             l += l & 1;
16096
16097           if (l < arch.sym_size)
16098             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16099                    file_name, arch.sym_size - l);
16100
16101           if (fseek (file, current_pos, SEEK_SET) != 0)
16102             {
16103               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16104               ret = 1;
16105               goto out;
16106             }
16107         }
16108
16109       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16110           && !do_segments && !do_header && !do_dump && !do_version
16111           && !do_histogram && !do_debugging && !do_arch && !do_notes
16112           && !do_section_groups && !do_dyn_syms)
16113         {
16114           ret = 0; /* Archive index only.  */
16115           goto out;
16116         }
16117     }
16118
16119   ret = 0;
16120
16121   while (1)
16122     {
16123       char * name;
16124       size_t namelen;
16125       char * qualified_name;
16126
16127       /* Read the next archive header.  */
16128       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16129         {
16130           error (_("%s: failed to seek to next archive header\n"), file_name);
16131           return 1;
16132         }
16133       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16134       if (got != sizeof arch.arhdr)
16135         {
16136           if (got == 0)
16137             break;
16138           error (_("%s: failed to read archive header\n"), file_name);
16139           ret = 1;
16140           break;
16141         }
16142       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16143         {
16144           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16145           ret = 1;
16146           break;
16147         }
16148
16149       arch.next_arhdr_offset += sizeof arch.arhdr;
16150
16151       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16152       if (archive_file_size & 01)
16153         ++archive_file_size;
16154
16155       name = get_archive_member_name (&arch, &nested_arch);
16156       if (name == NULL)
16157         {
16158           error (_("%s: bad archive file name\n"), file_name);
16159           ret = 1;
16160           break;
16161         }
16162       namelen = strlen (name);
16163
16164       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16165       if (qualified_name == NULL)
16166         {
16167           error (_("%s: bad archive file name\n"), file_name);
16168           ret = 1;
16169           break;
16170         }
16171
16172       if (is_thin_archive && arch.nested_member_origin == 0)
16173         {
16174           /* This is a proxy for an external member of a thin archive.  */
16175           FILE * member_file;
16176           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16177           if (member_file_name == NULL)
16178             {
16179               ret = 1;
16180               break;
16181             }
16182
16183           member_file = fopen (member_file_name, "rb");
16184           if (member_file == NULL)
16185             {
16186               error (_("Input file '%s' is not readable.\n"), member_file_name);
16187               free (member_file_name);
16188               ret = 1;
16189               break;
16190             }
16191
16192           archive_file_offset = arch.nested_member_origin;
16193
16194           ret |= process_object (qualified_name, member_file);
16195
16196           fclose (member_file);
16197           free (member_file_name);
16198         }
16199       else if (is_thin_archive)
16200         {
16201           /* PR 15140: Allow for corrupt thin archives.  */
16202           if (nested_arch.file == NULL)
16203             {
16204               error (_("%s: contains corrupt thin archive: %s\n"),
16205                      file_name, name);
16206               ret = 1;
16207               break;
16208             }
16209
16210           /* This is a proxy for a member of a nested archive.  */
16211           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16212
16213           /* The nested archive file will have been opened and setup by
16214              get_archive_member_name.  */
16215           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16216             {
16217               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16218               ret = 1;
16219               break;
16220             }
16221
16222           ret |= process_object (qualified_name, nested_arch.file);
16223         }
16224       else
16225         {
16226           archive_file_offset = arch.next_arhdr_offset;
16227           arch.next_arhdr_offset += archive_file_size;
16228
16229           ret |= process_object (qualified_name, file);
16230         }
16231
16232       if (dump_sects != NULL)
16233         {
16234           free (dump_sects);
16235           dump_sects = NULL;
16236           num_dump_sects = 0;
16237         }
16238
16239       free (qualified_name);
16240     }
16241
16242  out:
16243   if (nested_arch.file != NULL)
16244     fclose (nested_arch.file);
16245   release_archive (&nested_arch);
16246   release_archive (&arch);
16247
16248   return ret;
16249 }
16250
16251 static int
16252 process_file (char * file_name)
16253 {
16254   FILE * file;
16255   struct stat statbuf;
16256   char armag[SARMAG];
16257   int ret;
16258
16259   if (stat (file_name, &statbuf) < 0)
16260     {
16261       if (errno == ENOENT)
16262         error (_("'%s': No such file\n"), file_name);
16263       else
16264         error (_("Could not locate '%s'.  System error message: %s\n"),
16265                file_name, strerror (errno));
16266       return 1;
16267     }
16268
16269   if (! S_ISREG (statbuf.st_mode))
16270     {
16271       error (_("'%s' is not an ordinary file\n"), file_name);
16272       return 1;
16273     }
16274
16275   file = fopen (file_name, "rb");
16276   if (file == NULL)
16277     {
16278       error (_("Input file '%s' is not readable.\n"), file_name);
16279       return 1;
16280     }
16281
16282   if (fread (armag, SARMAG, 1, file) != 1)
16283     {
16284       error (_("%s: Failed to read file's magic number\n"), file_name);
16285       fclose (file);
16286       return 1;
16287     }
16288
16289   current_file_size = (bfd_size_type) statbuf.st_size;
16290
16291   if (memcmp (armag, ARMAG, SARMAG) == 0)
16292     ret = process_archive (file_name, file, FALSE);
16293   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16294     ret = process_archive (file_name, file, TRUE);
16295   else
16296     {
16297       if (do_archive_index)
16298         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16299                file_name);
16300
16301       rewind (file);
16302       archive_file_size = archive_file_offset = 0;
16303       ret = process_object (file_name, file);
16304     }
16305
16306   fclose (file);
16307
16308   current_file_size = 0;
16309   return ret;
16310 }
16311
16312 #ifdef SUPPORT_DISASSEMBLY
16313 /* Needed by the i386 disassembler.  For extra credit, someone could
16314    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16315    symbols.  */
16316
16317 void
16318 print_address (unsigned int addr, FILE * outfile)
16319 {
16320   fprintf (outfile,"0x%8.8x", addr);
16321 }
16322
16323 /* Needed by the i386 disassembler.  */
16324 void
16325 db_task_printsym (unsigned int addr)
16326 {
16327   print_address (addr, stderr);
16328 }
16329 #endif
16330
16331 int
16332 main (int argc, char ** argv)
16333 {
16334   int err;
16335
16336 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16337   setlocale (LC_MESSAGES, "");
16338 #endif
16339 #if defined (HAVE_SETLOCALE)
16340   setlocale (LC_CTYPE, "");
16341 #endif
16342   bindtextdomain (PACKAGE, LOCALEDIR);
16343   textdomain (PACKAGE);
16344
16345   expandargv (&argc, &argv);
16346
16347   parse_args (argc, argv);
16348
16349   if (num_dump_sects > 0)
16350     {
16351       /* Make a copy of the dump_sects array.  */
16352       cmdline_dump_sects = (dump_type *)
16353           malloc (num_dump_sects * sizeof (* dump_sects));
16354       if (cmdline_dump_sects == NULL)
16355         error (_("Out of memory allocating dump request table.\n"));
16356       else
16357         {
16358           memcpy (cmdline_dump_sects, dump_sects,
16359                   num_dump_sects * sizeof (* dump_sects));
16360           num_cmdline_dump_sects = num_dump_sects;
16361         }
16362     }
16363
16364   if (optind < (argc - 1))
16365     show_name = 1;
16366   else if (optind >= argc)
16367     {
16368       warn (_("Nothing to do.\n"));
16369       usage (stderr);
16370     }
16371
16372   err = 0;
16373   while (optind < argc)
16374     err |= process_file (argv[optind++]);
16375
16376   if (dump_sects != NULL)
16377     free (dump_sects);
16378   if (cmdline_dump_sects != NULL)
16379     free (cmdline_dump_sects);
16380
16381   return err;
16382 }