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 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/ft32.h"
 110 #include "elf/h8.h"
 111 #include "elf/hppa.h"
 112 #include "elf/i386.h"
 113 #include "elf/i370.h"
 114 #include "elf/i860.h"
 115 #include "elf/i960.h"
 116 #include "elf/ia64.h"
 117 #include "elf/ip2k.h"
 118 #include "elf/lm32.h"
 119 #include "elf/iq2000.h"
 120 #include "elf/m32c.h"
 121 #include "elf/m32r.h"
 122 #include "elf/m68k.h"
 123 #include "elf/m68hc11.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nios2.h"
 137 #include "elf/or1k.h"
 138 #include "elf/pj.h"
 139 #include "elf/ppc.h"
 140 #include "elf/ppc64.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/x86-64.h"
 155 #include "elf/xc16x.h"
 156 #include "elf/xgate.h"
 157 #include "elf/xstormy16.h"
 158 #include "elf/xtensa.h"
 159
 160 #include "getopt.h"
 161 #include "libiberty.h"
 162 #include "safe-ctype.h"
 163 #include "filenames.h"
 164
 165 #ifndef offsetof
 166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 167 #endif
 168
 169 char * program_name = "readelf";
 170 static unsigned long archive_file_offset;
 171 static unsigned long archive_file_size;
 172 static bfd_size_type current_file_size;
 173 static unsigned long dynamic_addr;
 174 static bfd_size_type dynamic_size;
 175 static size_t dynamic_nent;
 176 static char * dynamic_strings;
 177 static unsigned long dynamic_strings_length;
 178 static char * string_table;
 179 static unsigned long string_table_length;
 180 static unsigned long num_dynamic_syms;
 181 static Elf_Internal_Sym * dynamic_symbols;
 182 static Elf_Internal_Syminfo * dynamic_syminfo;
 183 static unsigned long dynamic_syminfo_offset;
 184 static unsigned int dynamic_syminfo_nent;
 185 static char program_interpreter[PATH_MAX];
 186 static bfd_vma dynamic_info[DT_ENCODING];
 187 static bfd_vma dynamic_info_DT_GNU_HASH;
 188 static bfd_vma version_info[16];
 189 static Elf_Internal_Ehdr elf_header;
 190 static Elf_Internal_Shdr * section_headers;
 191 static Elf_Internal_Phdr * program_headers;
 192 static Elf_Internal_Dyn *  dynamic_section;
 193 static Elf_Internal_Shdr * symtab_shndx_hdr;
 194 static int show_name;
 195 static int do_dynamic;
 196 static int do_syms;
 197 static int do_dyn_syms;
 198 static int do_reloc;
 199 static int do_sections;
 200 static int do_section_groups;
 201 static int do_section_details;
 202 static int do_segments;
 203 static int do_unwind;
 204 static int do_using_dynamic;
 205 static int do_header;
 206 static int do_dump;
 207 static int do_version;
 208 static int do_histogram;
 209 static int do_debugging;
 210 static int do_arch;
 211 static int do_notes;
 212 static int do_archive_index;
 213 static int is_32bit_elf;
 214
 215 struct group_list
 216 {
 217   struct group_list * next;
 218   unsigned int section_index;
 219 };
 220
 221 struct group
 222 {
 223   struct group_list * root;
 224   unsigned int group_index;
 225 };
 226
 227 static size_t group_count;
 228 static struct group * section_groups;
 229 static struct group ** section_headers_groups;
 230
 231
 232 /* Flag bits indicating particular types of dump.  */
 233 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 234 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 235 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 236 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 237 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 238
 239 typedef unsigned char dump_type;
 240
 241 /* A linked list of the section names for which dumps were requested.  */
 242 struct dump_list_entry
 243 {
 244   char * name;
 245   dump_type type;
 246   struct dump_list_entry * next;
 247 };
 248 static struct dump_list_entry * dump_sects_byname;
 249
 250 /* A dynamic array of flags indicating for which sections a dump
 251    has been requested via command line switches.  */
 252 static dump_type *   cmdline_dump_sects = NULL;
 253 static unsigned int  num_cmdline_dump_sects = 0;
 254
 255 /* A dynamic array of flags indicating for which sections a dump of
 256    some kind has been requested.  It is reset on a per-object file
 257    basis and then initialised from the cmdline_dump_sects array,
 258    the results of interpreting the -w switch, and the
 259    dump_sects_byname list.  */
 260 static dump_type *   dump_sects = NULL;
 261 static unsigned int  num_dump_sects = 0;
 262
 263
 264 /* How to print a vma value.  */
 265 typedef enum print_mode
 266 {
 267   HEX,
 268   DEC,
 269   DEC_5,
 270   UNSIGNED,
 271   PREFIX_HEX,
 272   FULL_HEX,
 273   LONG_HEX
 274 }
 275 print_mode;
 276
 277 /* Versioned symbol info.  */
 278 enum versioned_symbol_info
 279 {
 280   symbol_undefined,
 281   symbol_hidden,
 282   symbol_public
 283 };
 284
 285 static const char *get_symbol_version_string
 286   (FILE *file, int is_dynsym, const char *strtab,
 287    unsigned long int strtab_size, unsigned int si,
 288    Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
 289    unsigned short *vna_other);
 290
 291 #define UNKNOWN -1
 292
 293 #define SECTION_NAME(X)                                         \
 294   ((X) == NULL ? _("<none>")                                    \
 295    : string_table == NULL ? _("<no-name>")                      \
 296    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 297   : string_table + (X)->sh_name))
 298
 299 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 300
 301 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 302   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 303    : get_64bit_elf_symbols (file, section, sym_count))
 304
 305 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 307    already been called and verified that the string exists.  */
 308 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 309
 310 #define REMOVE_ARCH_BITS(ADDR)                  \
 311   do                                            \
 312     {                                           \
 313       if (elf_header.e_machine == EM_ARM)       \
 314         (ADDR) &= ~1;                           \
 315     }                                           \
 316   while (0)
 317 \f
 318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 319    the offset of the current archive member, if we are examining an archive.
 320    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 321    using malloc and fill that.  In either case return the pointer to the start of
 322    the retrieved data or NULL if something went wrong.  If something does go wrong
 323    and REASON is not NULL then emit an error message using REASON as part of the
 324    context.  */
 325
 326 static void *
 327 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 328           bfd_size_type nmemb, const char * reason)
 329 {
 330   void * mvar;
 331   bfd_size_type amt = size * nmemb;
 332
 333   if (size == 0 || nmemb == 0)
 334     return NULL;
 335
 336   /* If the size_t type is smaller than the bfd_size_type, eg because
 337      you are building a 32-bit tool on a 64-bit host, then make sure
 338      that when the sizes are cast to (size_t) no information is lost.  */
 339   if (sizeof (size_t) < sizeof (bfd_size_type)
 340       && (   (bfd_size_type) ((size_t) size) != size
 341           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 342     {
 343       if (reason)
 344         error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 345                (unsigned long long) nmemb, (unsigned long long) size, reason);
 346       return NULL;
 347     }
 348
 349   /* Check for size overflow.  */
 350   if (amt < nmemb)
 351     {
 352       if (reason)
 353         error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 354                (unsigned long long) nmemb, (unsigned long long) size, reason);
 355       return NULL;
 356     }
 357
 358   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 359      attempting to allocate memory when the read is bound to fail.  */
 360   if (amt > current_file_size
 361       || offset + archive_file_offset + amt > current_file_size)
 362     {
 363       if (reason)
 364         error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
 365                (unsigned long long) amt, reason);
 366       return NULL;
 367     }
 368
 369   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 370     {
 371       if (reason)
 372         error (_("Unable to seek to 0x%lx for %s\n"),
 373                (unsigned long) archive_file_offset + offset, reason);
 374       return NULL;
 375     }
 376
 377   mvar = var;
 378   if (mvar == NULL)
 379     {
 380       /* Check for overflow.  */
 381       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 382         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 383         mvar = malloc ((size_t) amt + 1);
 384
 385       if (mvar == NULL)
 386         {
 387           if (reason)
 388             error (_("Out of memory allocating 0x%llx bytes for %s\n"),
 389                    (unsigned long long) amt, reason);
 390           return NULL;
 391         }
 392
 393       ((char *) mvar)[amt] = '\0';
 394     }
 395
 396   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 397     {
 398       if (reason)
 399         error (_("Unable to read in 0x%llx bytes of %s\n"),
 400                (unsigned long long) amt, reason);
 401       if (mvar != var)
 402         free (mvar);
 403       return NULL;
 404     }
 405
 406   return mvar;
 407 }
 408
 409 /* Print a VMA value.  */
 410
 411 static int
 412 print_vma (bfd_vma vma, print_mode mode)
 413 {
 414   int nc = 0;
 415
 416   switch (mode)
 417     {
 418     case FULL_HEX:
 419       nc = printf ("0x");
 420       /* Drop through.  */
 421
 422     case LONG_HEX:
 423 #ifdef BFD64
 424       if (is_32bit_elf)
 425         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 426 #endif
 427       printf_vma (vma);
 428       return nc + 16;
 429
 430     case DEC_5:
 431       if (vma <= 99999)
 432         return printf ("%5" BFD_VMA_FMT "d", vma);
 433       /* Drop through.  */
 434
 435     case PREFIX_HEX:
 436       nc = printf ("0x");
 437       /* Drop through.  */
 438
 439     case HEX:
 440       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 441
 442     case DEC:
 443       return printf ("%" BFD_VMA_FMT "d", vma);
 444
 445     case UNSIGNED:
 446       return printf ("%" BFD_VMA_FMT "u", vma);
 447     }
 448   return 0;
 449 }
 450
 451 /* Display a symbol on stdout.  Handles the display of control characters and
 452    multibye characters (assuming the host environment supports them).
 453
 454    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 455
 456    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 457    padding as necessary.
 458
 459    Returns the number of emitted characters.  */
 460
 461 static unsigned int
 462 print_symbol (int width, const char *symbol)
 463 {
 464   bfd_boolean extra_padding = FALSE;
 465   int num_printed = 0;
 466 #ifdef HAVE_MBSTATE_T
 467   mbstate_t state;
 468 #endif
 469   int width_remaining;
 470
 471   if (width < 0)
 472     {
 473       /* Keep the width positive.  This also helps.  */
 474       width = - width;
 475       extra_padding = TRUE;
 476     }
 477   assert (width != 0);
 478
 479   if (do_wide)
 480     /* Set the remaining width to a very large value.
 481        This simplifies the code below.  */
 482     width_remaining = INT_MAX;
 483   else
 484     width_remaining = width;
 485
 486 #ifdef HAVE_MBSTATE_T
 487   /* Initialise the multibyte conversion state.  */
 488   memset (& state, 0, sizeof (state));
 489 #endif
 490
 491   while (width_remaining)
 492     {
 493       size_t  n;
 494       const char c = *symbol++;
 495
 496       if (c == 0)
 497         break;
 498
 499       /* Do not print control characters directly as they can affect terminal
 500          settings.  Such characters usually appear in the names generated
 501          by the assembler for local labels.  */
 502       if (ISCNTRL (c))
 503         {
 504           if (width_remaining < 2)
 505             break;
 506
 507           printf ("^%c", c + 0x40);
 508           width_remaining -= 2;
 509           num_printed += 2;
 510         }
 511       else if (ISPRINT (c))
 512         {
 513           putchar (c);
 514           width_remaining --;
 515           num_printed ++;
 516         }
 517       else
 518         {
 519 #ifdef HAVE_MBSTATE_T
 520           wchar_t w;
 521 #endif
 522           /* Let printf do the hard work of displaying multibyte characters.  */
 523           printf ("%.1s", symbol - 1);
 524           width_remaining --;
 525           num_printed ++;
 526
 527 #ifdef HAVE_MBSTATE_T
 528           /* Try to find out how many bytes made up the character that was
 529              just printed.  Advance the symbol pointer past the bytes that
 530              were displayed.  */
 531           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 532 #else
 533           n = 1;
 534 #endif
 535           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 536             symbol += (n - 1);
 537         }
 538     }
 539
 540   if (extra_padding && num_printed < width)
 541     {
 542       /* Fill in the remaining spaces.  */
 543       printf ("%-*s", width - num_printed, " ");
 544       num_printed = width;
 545     }
 546
 547   return num_printed;
 548 }
 549
 550 /* Returns a pointer to a static buffer containing a  printable version of
 551    the given section's name.  Like print_symbol, except that it does not try
 552    to print multibyte characters, it just interprets them as hex values.  */
 553
 554 static const char *
 555 printable_section_name (Elf_Internal_Shdr * sec)
 556 {
 557 #define MAX_PRINT_SEC_NAME_LEN 128
 558   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 559   const char * name = SECTION_NAME (sec);
 560   char *       buf = sec_name_buf;
 561   char         c;
 562   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 563
 564   while ((c = * name ++) != 0)
 565     {
 566       if (ISCNTRL (c))
 567         {
 568           if (remaining < 2)
 569             break;
 570
 571           * buf ++ = '^';
 572           * buf ++ = c + 0x40;
 573           remaining -= 2;
 574         }
 575       else if (ISPRINT (c))
 576         {
 577           * buf ++ = c;
 578           remaining -= 1;
 579         }
 580       else
 581         {
 582           static char hex[17] = "0123456789ABCDEF";
 583
 584           if (remaining < 4)
 585             break;
 586           * buf ++ = '<';
 587           * buf ++ = hex[(c & 0xf0) >> 4];
 588           * buf ++ = hex[c & 0x0f];
 589           * buf ++ = '>';
 590           remaining -= 4;
 591         }
 592
 593       if (remaining == 0)
 594         break;
 595     }
 596
 597   * buf = 0;
 598   return sec_name_buf;
 599 }
 600
 601 static const char *
 602 printable_section_name_from_index (unsigned long ndx)
 603 {
 604   if (ndx >= elf_header.e_shnum)
 605     return _("<corrupt>");
 606
 607   return printable_section_name (section_headers + ndx);
 608 }
 609
 610 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 611
 612 static Elf_Internal_Shdr *
 613 find_section (const char * name)
 614 {
 615   unsigned int i;
 616
 617   for (i = 0; i < elf_header.e_shnum; i++)
 618     if (streq (SECTION_NAME (section_headers + i), name))
 619       return section_headers + i;
 620
 621   return NULL;
 622 }
 623
 624 /* Return a pointer to a section containing ADDR, or NULL if no such
 625    section exists.  */
 626
 627 static Elf_Internal_Shdr *
 628 find_section_by_address (bfd_vma addr)
 629 {
 630   unsigned int i;
 631
 632   for (i = 0; i < elf_header.e_shnum; i++)
 633     {
 634       Elf_Internal_Shdr *sec = section_headers + i;
 635       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 636         return sec;
 637     }
 638
 639   return NULL;
 640 }
 641
 642 static Elf_Internal_Shdr *
 643 find_section_by_type (unsigned int type)
 644 {
 645   unsigned int i;
 646
 647   for (i = 0; i < elf_header.e_shnum; i++)
 648     {
 649       Elf_Internal_Shdr *sec = section_headers + i;
 650       if (sec->sh_type == type)
 651         return sec;
 652     }
 653
 654   return NULL;
 655 }
 656
 657 /* Return a pointer to section NAME, or NULL if no such section exists,
 658    restricted to the list of sections given in SET.  */
 659
 660 static Elf_Internal_Shdr *
 661 find_section_in_set (const char * name, unsigned int * set)
 662 {
 663   unsigned int i;
 664
 665   if (set != NULL)
 666     {
 667       while ((i = *set++) > 0)
 668         if (streq (SECTION_NAME (section_headers + i), name))
 669           return section_headers + i;
 670     }
 671
 672   return find_section (name);
 673 }
 674
 675 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 676    bytes read.  */
 677
 678 static inline unsigned long
 679 read_uleb128 (unsigned char *data,
 680               unsigned int *length_return,
 681               const unsigned char * const end)
 682 {
 683   return read_leb128 (data, length_return, FALSE, end);
 684 }
 685
 686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 687    This OS has so many departures from the ELF standard that we test it at
 688    many places.  */
 689
 690 static inline int
 691 is_ia64_vms (void)
 692 {
 693   return elf_header.e_machine == EM_IA_64
 694     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 695 }
 696
 697 /* Guess the relocation size commonly used by the specific machines.  */
 698
 699 static int
 700 guess_is_rela (unsigned int e_machine)
 701 {
 702   switch (e_machine)
 703     {
 704       /* Targets that use REL relocations.  */
 705     case EM_386:
 706     case EM_486:
 707     case EM_960:
 708     case EM_ARM:
 709     case EM_D10V:
 710     case EM_CYGNUS_D10V:
 711     case EM_DLX:
 712     case EM_MIPS:
 713     case EM_MIPS_RS3_LE:
 714     case EM_CYGNUS_M32R:
 715     case EM_SCORE:
 716     case EM_XGATE:
 717       return FALSE;
 718
 719       /* Targets that use RELA relocations.  */
 720     case EM_68K:
 721     case EM_860:
 722     case EM_AARCH64:
 723     case EM_ADAPTEVA_EPIPHANY:
 724     case EM_ALPHA:
 725     case EM_ALTERA_NIOS2:
 726     case EM_AVR:
 727     case EM_AVR_OLD:
 728     case EM_BLACKFIN:
 729     case EM_CR16:
 730     case EM_CRIS:
 731     case EM_CRX:
 732     case EM_D30V:
 733     case EM_CYGNUS_D30V:
 734     case EM_FR30:
 735     case EM_FT32:
 736     case EM_CYGNUS_FR30:
 737     case EM_CYGNUS_FRV:
 738     case EM_H8S:
 739     case EM_H8_300:
 740     case EM_H8_300H:
 741     case EM_IA_64:
 742     case EM_IP2K:
 743     case EM_IP2K_OLD:
 744     case EM_IQ2000:
 745     case EM_LATTICEMICO32:
 746     case EM_M32C_OLD:
 747     case EM_M32C:
 748     case EM_M32R:
 749     case EM_MCORE:
 750     case EM_CYGNUS_MEP:
 751     case EM_METAG:
 752     case EM_MMIX:
 753     case EM_MN10200:
 754     case EM_CYGNUS_MN10200:
 755     case EM_MN10300:
 756     case EM_CYGNUS_MN10300:
 757     case EM_MOXIE:
 758     case EM_MSP430:
 759     case EM_MSP430_OLD:
 760     case EM_MT:
 761     case EM_NDS32:
 762     case EM_NIOS32:
 763     case EM_OR1K:
 764     case EM_PPC64:
 765     case EM_PPC:
 766     case EM_RL78:
 767     case EM_RX:
 768     case EM_S390:
 769     case EM_S390_OLD:
 770     case EM_SH:
 771     case EM_SPARC:
 772     case EM_SPARC32PLUS:
 773     case EM_SPARCV9:
 774     case EM_SPU:
 775     case EM_TI_C6000:
 776     case EM_TILEGX:
 777     case EM_TILEPRO:
 778     case EM_V800:
 779     case EM_V850:
 780     case EM_CYGNUS_V850:
 781     case EM_VAX:
 782     case EM_VISIUM:
 783     case EM_X86_64:
 784     case EM_L1OM:
 785     case EM_K1OM:
 786     case EM_XSTORMY16:
 787     case EM_XTENSA:
 788     case EM_XTENSA_OLD:
 789     case EM_MICROBLAZE:
 790     case EM_MICROBLAZE_OLD:
 791       return TRUE;
 792
 793     case EM_68HC05:
 794     case EM_68HC08:
 795     case EM_68HC11:
 796     case EM_68HC16:
 797     case EM_FX66:
 798     case EM_ME16:
 799     case EM_MMA:
 800     case EM_NCPU:
 801     case EM_NDR1:
 802     case EM_PCP:
 803     case EM_ST100:
 804     case EM_ST19:
 805     case EM_ST7:
 806     case EM_ST9PLUS:
 807     case EM_STARCORE:
 808     case EM_SVX:
 809     case EM_TINYJ:
 810     default:
 811       warn (_("Don't know about relocations on this machine architecture\n"));
 812       return FALSE;
 813     }
 814 }
 815
 816 static int
 817 slurp_rela_relocs (FILE * file,
 818                    unsigned long rel_offset,
 819                    unsigned long rel_size,
 820                    Elf_Internal_Rela ** relasp,
 821                    unsigned long * nrelasp)
 822 {
 823   Elf_Internal_Rela * relas;
 824   size_t nrelas;
 825   unsigned int i;
 826
 827   if (is_32bit_elf)
 828     {
 829       Elf32_External_Rela * erelas;
 830
 831       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 832                                                  rel_size, _("32-bit relocation data"));
 833       if (!erelas)
 834         return 0;
 835
 836       nrelas = rel_size / sizeof (Elf32_External_Rela);
 837
 838       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 839                                              sizeof (Elf_Internal_Rela));
 840
 841       if (relas == NULL)
 842         {
 843           free (erelas);
 844           error (_("out of memory parsing relocs\n"));
 845           return 0;
 846         }
 847
 848       for (i = 0; i < nrelas; i++)
 849         {
 850           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 851           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 852           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 853         }
 854
 855       free (erelas);
 856     }
 857   else
 858     {
 859       Elf64_External_Rela * erelas;
 860
 861       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 862                                                  rel_size, _("64-bit relocation data"));
 863       if (!erelas)
 864         return 0;
 865
 866       nrelas = rel_size / sizeof (Elf64_External_Rela);
 867
 868       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 869                                              sizeof (Elf_Internal_Rela));
 870
 871       if (relas == NULL)
 872         {
 873           free (erelas);
 874           error (_("out of memory parsing relocs\n"));
 875           return 0;
 876         }
 877
 878       for (i = 0; i < nrelas; i++)
 879         {
 880           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 881           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 882           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 883
 884           /* The #ifdef BFD64 below is to prevent a compile time
 885              warning.  We know that if we do not have a 64 bit data
 886              type that we will never execute this code anyway.  */
 887 #ifdef BFD64
 888           if (elf_header.e_machine == EM_MIPS
 889               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 890             {
 891               /* In little-endian objects, r_info isn't really a
 892                  64-bit little-endian value: it has a 32-bit
 893                  little-endian symbol index followed by four
 894                  individual byte fields.  Reorder INFO
 895                  accordingly.  */
 896               bfd_vma inf = relas[i].r_info;
 897               inf = (((inf & 0xffffffff) << 32)
 898                       | ((inf >> 56) & 0xff)
 899                       | ((inf >> 40) & 0xff00)
 900                       | ((inf >> 24) & 0xff0000)
 901                       | ((inf >> 8) & 0xff000000));
 902               relas[i].r_info = inf;
 903             }
 904 #endif /* BFD64 */
 905         }
 906
 907       free (erelas);
 908     }
 909   *relasp = relas;
 910   *nrelasp = nrelas;
 911   return 1;
 912 }
 913
 914 static int
 915 slurp_rel_relocs (FILE * file,
 916                   unsigned long rel_offset,
 917                   unsigned long rel_size,
 918                   Elf_Internal_Rela ** relsp,
 919                   unsigned long * nrelsp)
 920 {
 921   Elf_Internal_Rela * rels;
 922   size_t nrels;
 923   unsigned int i;
 924
 925   if (is_32bit_elf)
 926     {
 927       Elf32_External_Rel * erels;
 928
 929       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 930                                                rel_size, _("32-bit relocation data"));
 931       if (!erels)
 932         return 0;
 933
 934       nrels = rel_size / sizeof (Elf32_External_Rel);
 935
 936       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 937
 938       if (rels == NULL)
 939         {
 940           free (erels);
 941           error (_("out of memory parsing relocs\n"));
 942           return 0;
 943         }
 944
 945       for (i = 0; i < nrels; i++)
 946         {
 947           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 948           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 949           rels[i].r_addend = 0;
 950         }
 951
 952       free (erels);
 953     }
 954   else
 955     {
 956       Elf64_External_Rel * erels;
 957
 958       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 959                                                rel_size, _("64-bit relocation data"));
 960       if (!erels)
 961         return 0;
 962
 963       nrels = rel_size / sizeof (Elf64_External_Rel);
 964
 965       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 966
 967       if (rels == NULL)
 968         {
 969           free (erels);
 970           error (_("out of memory parsing relocs\n"));
 971           return 0;
 972         }
 973
 974       for (i = 0; i < nrels; i++)
 975         {
 976           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 977           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 978           rels[i].r_addend = 0;
 979
 980           /* The #ifdef BFD64 below is to prevent a compile time
 981              warning.  We know that if we do not have a 64 bit data
 982              type that we will never execute this code anyway.  */
 983 #ifdef BFD64
 984           if (elf_header.e_machine == EM_MIPS
 985               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 986             {
 987               /* In little-endian objects, r_info isn't really a
 988                  64-bit little-endian value: it has a 32-bit
 989                  little-endian symbol index followed by four
 990                  individual byte fields.  Reorder INFO
 991                  accordingly.  */
 992               bfd_vma inf = rels[i].r_info;
 993               inf = (((inf & 0xffffffff) << 32)
 994                      | ((inf >> 56) & 0xff)
 995                      | ((inf >> 40) & 0xff00)
 996                      | ((inf >> 24) & 0xff0000)
 997                      | ((inf >> 8) & 0xff000000));
 998               rels[i].r_info = inf;
 999             }
1000 #endif /* BFD64 */
1001         }
1002
1003       free (erels);
1004     }
1005   *relsp = rels;
1006   *nrelsp = nrels;
1007   return 1;
1008 }
1009
1010 /* Returns the reloc type extracted from the reloc info field.  */
1011
1012 static unsigned int
1013 get_reloc_type (bfd_vma reloc_info)
1014 {
1015   if (is_32bit_elf)
1016     return ELF32_R_TYPE (reloc_info);
1017
1018   switch (elf_header.e_machine)
1019     {
1020     case EM_MIPS:
1021       /* Note: We assume that reloc_info has already been adjusted for us.  */
1022       return ELF64_MIPS_R_TYPE (reloc_info);
1023
1024     case EM_SPARCV9:
1025       return ELF64_R_TYPE_ID (reloc_info);
1026
1027     default:
1028       return ELF64_R_TYPE (reloc_info);
1029     }
1030 }
1031
1032 /* Return the symbol index extracted from the reloc info field.  */
1033
1034 static bfd_vma
1035 get_reloc_symindex (bfd_vma reloc_info)
1036 {
1037   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1038 }
1039
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1042 {
1043   return
1044     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1045     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1046     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047         /* TI compiler uses ELFOSABI_NONE.  */
1048         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1049 }
1050
1051 /* Display the contents of the relocation data found at the specified
1052    offset.  */
1053
1054 static void
1055 dump_relocations (FILE * file,
1056                   unsigned long rel_offset,
1057                   unsigned long rel_size,
1058                   Elf_Internal_Sym * symtab,
1059                   unsigned long nsyms,
1060                   char * strtab,
1061                   unsigned long strtablen,
1062                   int is_rela,
1063                   int is_dynsym)
1064 {
1065   unsigned int i;
1066   Elf_Internal_Rela * rels;
1067
1068   if (is_rela == UNKNOWN)
1069     is_rela = guess_is_rela (elf_header.e_machine);
1070
1071   if (is_rela)
1072     {
1073       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1074         return;
1075     }
1076   else
1077     {
1078       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1079         return;
1080     }
1081
1082   if (is_32bit_elf)
1083     {
1084       if (is_rela)
1085         {
1086           if (do_wide)
1087             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1088           else
1089             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1090         }
1091       else
1092         {
1093           if (do_wide)
1094             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1095           else
1096             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1097         }
1098     }
1099   else
1100     {
1101       if (is_rela)
1102         {
1103           if (do_wide)
1104             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1105           else
1106             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1107         }
1108       else
1109         {
1110           if (do_wide)
1111             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1112           else
1113             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1114         }
1115     }
1116
1117   for (i = 0; i < rel_size; i++)
1118     {
1119       const char * rtype;
1120       bfd_vma offset;
1121       bfd_vma inf;
1122       bfd_vma symtab_index;
1123       bfd_vma type;
1124
1125       offset = rels[i].r_offset;
1126       inf    = rels[i].r_info;
1127
1128       type = get_reloc_type (inf);
1129       symtab_index = get_reloc_symindex  (inf);
1130
1131       if (is_32bit_elf)
1132         {
1133           printf ("%8.8lx  %8.8lx ",
1134                   (unsigned long) offset & 0xffffffff,
1135                   (unsigned long) inf & 0xffffffff);
1136         }
1137       else
1138         {
1139 #if BFD_HOST_64BIT_LONG
1140           printf (do_wide
1141                   ? "%16.16lx  %16.16lx "
1142                   : "%12.12lx  %12.12lx ",
1143                   offset, inf);
1144 #elif BFD_HOST_64BIT_LONG_LONG
1145 #ifndef __MSVCRT__
1146           printf (do_wide
1147                   ? "%16.16llx  %16.16llx "
1148                   : "%12.12llx  %12.12llx ",
1149                   offset, inf);
1150 #else
1151           printf (do_wide
1152                   ? "%16.16I64x  %16.16I64x "
1153                   : "%12.12I64x  %12.12I64x ",
1154                   offset, inf);
1155 #endif
1156 #else
1157           printf (do_wide
1158                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1159                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1160                   _bfd_int64_high (offset),
1161                   _bfd_int64_low (offset),
1162                   _bfd_int64_high (inf),
1163                   _bfd_int64_low (inf));
1164 #endif
1165         }
1166
1167       switch (elf_header.e_machine)
1168         {
1169         default:
1170           rtype = NULL;
1171           break;
1172
1173         case EM_AARCH64:
1174           rtype = elf_aarch64_reloc_type (type);
1175           break;
1176
1177         case EM_M32R:
1178         case EM_CYGNUS_M32R:
1179           rtype = elf_m32r_reloc_type (type);
1180           break;
1181
1182         case EM_386:
1183         case EM_486:
1184           rtype = elf_i386_reloc_type (type);
1185           break;
1186
1187         case EM_68HC11:
1188         case EM_68HC12:
1189           rtype = elf_m68hc11_reloc_type (type);
1190           break;
1191
1192         case EM_68K:
1193           rtype = elf_m68k_reloc_type (type);
1194           break;
1195
1196         case EM_960:
1197           rtype = elf_i960_reloc_type (type);
1198           break;
1199
1200         case EM_AVR:
1201         case EM_AVR_OLD:
1202           rtype = elf_avr_reloc_type (type);
1203           break;
1204
1205         case EM_OLD_SPARCV9:
1206         case EM_SPARC32PLUS:
1207         case EM_SPARCV9:
1208         case EM_SPARC:
1209           rtype = elf_sparc_reloc_type (type);
1210           break;
1211
1212         case EM_SPU:
1213           rtype = elf_spu_reloc_type (type);
1214           break;
1215
1216         case EM_V800:
1217           rtype = v800_reloc_type (type);
1218           break;
1219         case EM_V850:
1220         case EM_CYGNUS_V850:
1221           rtype = v850_reloc_type (type);
1222           break;
1223
1224         case EM_D10V:
1225         case EM_CYGNUS_D10V:
1226           rtype = elf_d10v_reloc_type (type);
1227           break;
1228
1229         case EM_D30V:
1230         case EM_CYGNUS_D30V:
1231           rtype = elf_d30v_reloc_type (type);
1232           break;
1233
1234         case EM_DLX:
1235           rtype = elf_dlx_reloc_type (type);
1236           break;
1237
1238         case EM_SH:
1239           rtype = elf_sh_reloc_type (type);
1240           break;
1241
1242         case EM_MN10300:
1243         case EM_CYGNUS_MN10300:
1244           rtype = elf_mn10300_reloc_type (type);
1245           break;
1246
1247         case EM_MN10200:
1248         case EM_CYGNUS_MN10200:
1249           rtype = elf_mn10200_reloc_type (type);
1250           break;
1251
1252         case EM_FR30:
1253         case EM_CYGNUS_FR30:
1254           rtype = elf_fr30_reloc_type (type);
1255           break;
1256
1257         case EM_CYGNUS_FRV:
1258           rtype = elf_frv_reloc_type (type);
1259           break;
1260
1261         case EM_FT32:
1262           rtype = elf_ft32_reloc_type (type);
1263           break;
1264
1265         case EM_MCORE:
1266           rtype = elf_mcore_reloc_type (type);
1267           break;
1268
1269         case EM_MMIX:
1270           rtype = elf_mmix_reloc_type (type);
1271           break;
1272
1273         case EM_MOXIE:
1274           rtype = elf_moxie_reloc_type (type);
1275           break;
1276
1277         case EM_MSP430:
1278           if (uses_msp430x_relocs ())
1279             {
1280               rtype = elf_msp430x_reloc_type (type);
1281               break;
1282             }
1283         case EM_MSP430_OLD:
1284           rtype = elf_msp430_reloc_type (type);
1285           break;
1286
1287         case EM_NDS32:
1288           rtype = elf_nds32_reloc_type (type);
1289           break;
1290
1291         case EM_PPC:
1292           rtype = elf_ppc_reloc_type (type);
1293           break;
1294
1295         case EM_PPC64:
1296           rtype = elf_ppc64_reloc_type (type);
1297           break;
1298
1299         case EM_MIPS:
1300         case EM_MIPS_RS3_LE:
1301           rtype = elf_mips_reloc_type (type);
1302           break;
1303
1304         case EM_ALPHA:
1305           rtype = elf_alpha_reloc_type (type);
1306           break;
1307
1308         case EM_ARM:
1309           rtype = elf_arm_reloc_type (type);
1310           break;
1311
1312         case EM_ARC:
1313           rtype = elf_arc_reloc_type (type);
1314           break;
1315
1316         case EM_PARISC:
1317           rtype = elf_hppa_reloc_type (type);
1318           break;
1319
1320         case EM_H8_300:
1321         case EM_H8_300H:
1322         case EM_H8S:
1323           rtype = elf_h8_reloc_type (type);
1324           break;
1325
1326         case EM_OR1K:
1327           rtype = elf_or1k_reloc_type (type);
1328           break;
1329
1330         case EM_PJ:
1331         case EM_PJ_OLD:
1332           rtype = elf_pj_reloc_type (type);
1333           break;
1334         case EM_IA_64:
1335           rtype = elf_ia64_reloc_type (type);
1336           break;
1337
1338         case EM_CRIS:
1339           rtype = elf_cris_reloc_type (type);
1340           break;
1341
1342         case EM_860:
1343           rtype = elf_i860_reloc_type (type);
1344           break;
1345
1346         case EM_X86_64:
1347         case EM_L1OM:
1348         case EM_K1OM:
1349           rtype = elf_x86_64_reloc_type (type);
1350           break;
1351
1352         case EM_S370:
1353           rtype = i370_reloc_type (type);
1354           break;
1355
1356         case EM_S390_OLD:
1357         case EM_S390:
1358           rtype = elf_s390_reloc_type (type);
1359           break;
1360
1361         case EM_SCORE:
1362           rtype = elf_score_reloc_type (type);
1363           break;
1364
1365         case EM_XSTORMY16:
1366           rtype = elf_xstormy16_reloc_type (type);
1367           break;
1368
1369         case EM_CRX:
1370           rtype = elf_crx_reloc_type (type);
1371           break;
1372
1373         case EM_VAX:
1374           rtype = elf_vax_reloc_type (type);
1375           break;
1376
1377         case EM_VISIUM:
1378           rtype = elf_visium_reloc_type (type);
1379           break;
1380
1381         case EM_ADAPTEVA_EPIPHANY:
1382           rtype = elf_epiphany_reloc_type (type);
1383           break;
1384
1385         case EM_IP2K:
1386         case EM_IP2K_OLD:
1387           rtype = elf_ip2k_reloc_type (type);
1388           break;
1389
1390         case EM_IQ2000:
1391           rtype = elf_iq2000_reloc_type (type);
1392           break;
1393
1394         case EM_XTENSA_OLD:
1395         case EM_XTENSA:
1396           rtype = elf_xtensa_reloc_type (type);
1397           break;
1398
1399         case EM_LATTICEMICO32:
1400           rtype = elf_lm32_reloc_type (type);
1401           break;
1402
1403         case EM_M32C_OLD:
1404         case EM_M32C:
1405           rtype = elf_m32c_reloc_type (type);
1406           break;
1407
1408         case EM_MT:
1409           rtype = elf_mt_reloc_type (type);
1410           break;
1411
1412         case EM_BLACKFIN:
1413           rtype = elf_bfin_reloc_type (type);
1414           break;
1415
1416         case EM_CYGNUS_MEP:
1417           rtype = elf_mep_reloc_type (type);
1418           break;
1419
1420         case EM_CR16:
1421           rtype = elf_cr16_reloc_type (type);
1422           break;
1423
1424         case EM_MICROBLAZE:
1425         case EM_MICROBLAZE_OLD:
1426           rtype = elf_microblaze_reloc_type (type);
1427           break;
1428
1429         case EM_RL78:
1430           rtype = elf_rl78_reloc_type (type);
1431           break;
1432
1433         case EM_RX:
1434           rtype = elf_rx_reloc_type (type);
1435           break;
1436
1437         case EM_METAG:
1438           rtype = elf_metag_reloc_type (type);
1439           break;
1440
1441         case EM_XC16X:
1442         case EM_C166:
1443           rtype = elf_xc16x_reloc_type (type);
1444           break;
1445
1446         case EM_TI_C6000:
1447           rtype = elf_tic6x_reloc_type (type);
1448           break;
1449
1450         case EM_TILEGX:
1451           rtype = elf_tilegx_reloc_type (type);
1452           break;
1453
1454         case EM_TILEPRO:
1455           rtype = elf_tilepro_reloc_type (type);
1456           break;
1457
1458         case EM_XGATE:
1459           rtype = elf_xgate_reloc_type (type);
1460           break;
1461
1462         case EM_ALTERA_NIOS2:
1463           rtype = elf_nios2_reloc_type (type);
1464           break;
1465         }
1466
1467       if (rtype == NULL)
1468         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1469       else
1470         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1471
1472       if (elf_header.e_machine == EM_ALPHA
1473           && rtype != NULL
1474           && streq (rtype, "R_ALPHA_LITUSE")
1475           && is_rela)
1476         {
1477           switch (rels[i].r_addend)
1478             {
1479             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1480             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1481             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1483             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1484             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486             default: rtype = NULL;
1487             }
1488           if (rtype)
1489             printf (" (%s)", rtype);
1490           else
1491             {
1492               putchar (' ');
1493               printf (_("<unknown addend: %lx>"),
1494                       (unsigned long) rels[i].r_addend);
1495             }
1496         }
1497       else if (symtab_index)
1498         {
1499           if (symtab == NULL || symtab_index >= nsyms)
1500             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1501           else
1502             {
1503               Elf_Internal_Sym * psym;
1504               const char * version_string;
1505               enum versioned_symbol_info sym_info;
1506               unsigned short vna_other;
1507
1508               psym = symtab + symtab_index;
1509
1510               version_string
1511                 = get_symbol_version_string (file, is_dynsym,
1512                                              strtab, strtablen,
1513                                              symtab_index,
1514                                              psym,
1515                                              &sym_info,
1516                                              &vna_other);
1517
1518               printf (" ");
1519
1520               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1521                 {
1522                   const char * name;
1523                   unsigned int len;
1524                   unsigned int width = is_32bit_elf ? 8 : 14;
1525
1526                   /* Relocations against GNU_IFUNC symbols do not use the value
1527                      of the symbol as the address to relocate against.  Instead
1528                      they invoke the function named by the symbol and use its
1529                      result as the address for relocation.
1530
1531                      To indicate this to the user, do not display the value of
1532                      the symbol in the "Symbols's Value" field.  Instead show
1533                      its name followed by () as a hint that the symbol is
1534                      invoked.  */
1535
1536                   if (strtab == NULL
1537                       || psym->st_name == 0
1538                       || psym->st_name >= strtablen)
1539                     name = "??";
1540                   else
1541                     name = strtab + psym->st_name;
1542
1543                   len = print_symbol (width, name);
1544                   if (version_string)
1545                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1546                             version_string);
1547                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1548                 }
1549               else
1550                 {
1551                   print_vma (psym->st_value, LONG_HEX);
1552
1553                   printf (is_32bit_elf ? "   " : " ");
1554                 }
1555
1556               if (psym->st_name == 0)
1557                 {
1558                   const char * sec_name = "<null>";
1559                   char name_buf[40];
1560
1561                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1562                     {
1563                       if (psym->st_shndx < elf_header.e_shnum)
1564                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1565                       else if (psym->st_shndx == SHN_ABS)
1566                         sec_name = "ABS";
1567                       else if (psym->st_shndx == SHN_COMMON)
1568                         sec_name = "COMMON";
1569                       else if ((elf_header.e_machine == EM_MIPS
1570                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571                                || (elf_header.e_machine == EM_TI_C6000
1572                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1573                         sec_name = "SCOMMON";
1574                       else if (elf_header.e_machine == EM_MIPS
1575                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576                         sec_name = "SUNDEF";
1577                       else if ((elf_header.e_machine == EM_X86_64
1578                                 || elf_header.e_machine == EM_L1OM
1579                                 || elf_header.e_machine == EM_K1OM)
1580                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1581                         sec_name = "LARGE_COMMON";
1582                       else if (elf_header.e_machine == EM_IA_64
1583                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585                         sec_name = "ANSI_COM";
1586                       else if (is_ia64_vms ()
1587                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588                         sec_name = "VMS_SYMVEC";
1589                       else
1590                         {
1591                           sprintf (name_buf, "<section 0x%x>",
1592                                    (unsigned int) psym->st_shndx);
1593                           sec_name = name_buf;
1594                         }
1595                     }
1596                   print_symbol (22, sec_name);
1597                 }
1598               else if (strtab == NULL)
1599                 printf (_("<string table index: %3ld>"), psym->st_name);
1600               else if (psym->st_name >= strtablen)
1601                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1602               else
1603                 {
1604                   print_symbol (22, strtab + psym->st_name);
1605                   if (version_string)
1606                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1607                             version_string);
1608                 }
1609
1610               if (is_rela)
1611                 {
1612                   bfd_signed_vma off = rels[i].r_addend;
1613
1614                   /* PR 17531: file: 2e63226f.  */
1615                   if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1616                     printf (" + %" BFD_VMA_FMT "x", off);
1617                   else if (off < 0)
1618                     printf (" - %" BFD_VMA_FMT "x", - off);
1619                   else
1620                     printf (" + %" BFD_VMA_FMT "x", off);
1621                 }
1622             }
1623         }
1624       else if (is_rela)
1625         {
1626           bfd_signed_vma off = rels[i].r_addend;
1627
1628           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1629           /* PR 17531: file: 2e63226f.  */
1630           if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1631             printf ("%" BFD_VMA_FMT "x", off);
1632           else if (off < 0)
1633             printf ("-%" BFD_VMA_FMT "x", - off);
1634           else
1635             printf ("%" BFD_VMA_FMT "x", off);
1636         }
1637
1638       if (elf_header.e_machine == EM_SPARCV9
1639           && rtype != NULL
1640           && streq (rtype, "R_SPARC_OLO10"))
1641         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1642
1643       putchar ('\n');
1644
1645 #ifdef BFD64
1646       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1647         {
1648           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1649           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1650           const char * rtype2 = elf_mips_reloc_type (type2);
1651           const char * rtype3 = elf_mips_reloc_type (type3);
1652
1653           printf ("                    Type2: ");
1654
1655           if (rtype2 == NULL)
1656             printf (_("unrecognized: %-7lx"),
1657                     (unsigned long) type2 & 0xffffffff);
1658           else
1659             printf ("%-17.17s", rtype2);
1660
1661           printf ("\n                    Type3: ");
1662
1663           if (rtype3 == NULL)
1664             printf (_("unrecognized: %-7lx"),
1665                     (unsigned long) type3 & 0xffffffff);
1666           else
1667             printf ("%-17.17s", rtype3);
1668
1669           putchar ('\n');
1670         }
1671 #endif /* BFD64 */
1672     }
1673
1674   free (rels);
1675 }
1676
1677 static const char *
1678 get_mips_dynamic_type (unsigned long type)
1679 {
1680   switch (type)
1681     {
1682     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1683     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1684     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1685     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1686     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1687     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1688     case DT_MIPS_MSYM: return "MIPS_MSYM";
1689     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1690     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1691     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1692     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1693     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1694     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1695     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1696     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1697     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1698     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1699     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1725     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1727     default:
1728       return NULL;
1729     }
1730 }
1731
1732 static const char *
1733 get_sparc64_dynamic_type (unsigned long type)
1734 {
1735   switch (type)
1736     {
1737     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738     default:
1739       return NULL;
1740     }
1741 }
1742
1743 static const char *
1744 get_ppc_dynamic_type (unsigned long type)
1745 {
1746   switch (type)
1747     {
1748     case DT_PPC_GOT:    return "PPC_GOT";
1749     case DT_PPC_OPT:    return "PPC_OPT";
1750     default:
1751       return NULL;
1752     }
1753 }
1754
1755 static const char *
1756 get_ppc64_dynamic_type (unsigned long type)
1757 {
1758   switch (type)
1759     {
1760     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1761     case DT_PPC64_OPD:    return "PPC64_OPD";
1762     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1763     case DT_PPC64_OPT:    return "PPC64_OPT";
1764     default:
1765       return NULL;
1766     }
1767 }
1768
1769 static const char *
1770 get_parisc_dynamic_type (unsigned long type)
1771 {
1772   switch (type)
1773     {
1774     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1775     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1776     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1777     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1778     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1779     case DT_HP_PREINIT:         return "HP_PREINIT";
1780     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1781     case DT_HP_NEEDED:          return "HP_NEEDED";
1782     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1783     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1784     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1785     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1786     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1787     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1788     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1789     case DT_HP_FILTERED:        return "HP_FILTERED";
1790     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1791     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1793     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1794     case DT_PLT:                return "PLT";
1795     case DT_PLT_SIZE:           return "PLT_SIZE";
1796     case DT_DLT:                return "DLT";
1797     case DT_DLT_SIZE:           return "DLT_SIZE";
1798     default:
1799       return NULL;
1800     }
1801 }
1802
1803 static const char *
1804 get_ia64_dynamic_type (unsigned long type)
1805 {
1806   switch (type)
1807     {
1808     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1809     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1810     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1811     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1812     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1814     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1815     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1816     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1817     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1818     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1819     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1820     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1821     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1822     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1823     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1824     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1825     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1826     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1827     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1828     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1829     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1830     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1831     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1832     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1833     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1834     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1835     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1836     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1837     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1838     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1839     default:
1840       return NULL;
1841     }
1842 }
1843
1844 static const char *
1845 get_alpha_dynamic_type (unsigned long type)
1846 {
1847   switch (type)
1848     {
1849     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_score_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1862     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1863     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1864     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1865     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1866     default:
1867       return NULL;
1868     }
1869 }
1870
1871 static const char *
1872 get_tic6x_dynamic_type (unsigned long type)
1873 {
1874   switch (type)
1875     {
1876     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1879     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1880     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1881     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1882     default:
1883       return NULL;
1884     }
1885 }
1886
1887 static const char *
1888 get_nios2_dynamic_type (unsigned long type)
1889 {
1890   switch (type)
1891     {
1892     case DT_NIOS2_GP: return "NIOS2_GP";
1893     default:
1894       return NULL;
1895     }
1896 }
1897
1898 static const char *
1899 get_dynamic_type (unsigned long type)
1900 {
1901   static char buff[64];
1902
1903   switch (type)
1904     {
1905     case DT_NULL:       return "NULL";
1906     case DT_NEEDED:     return "NEEDED";
1907     case DT_PLTRELSZ:   return "PLTRELSZ";
1908     case DT_PLTGOT:     return "PLTGOT";
1909     case DT_HASH:       return "HASH";
1910     case DT_STRTAB:     return "STRTAB";
1911     case DT_SYMTAB:     return "SYMTAB";
1912     case DT_RELA:       return "RELA";
1913     case DT_RELASZ:     return "RELASZ";
1914     case DT_RELAENT:    return "RELAENT";
1915     case DT_STRSZ:      return "STRSZ";
1916     case DT_SYMENT:     return "SYMENT";
1917     case DT_INIT:       return "INIT";
1918     case DT_FINI:       return "FINI";
1919     case DT_SONAME:     return "SONAME";
1920     case DT_RPATH:      return "RPATH";
1921     case DT_SYMBOLIC:   return "SYMBOLIC";
1922     case DT_REL:        return "REL";
1923     case DT_RELSZ:      return "RELSZ";
1924     case DT_RELENT:     return "RELENT";
1925     case DT_PLTREL:     return "PLTREL";
1926     case DT_DEBUG:      return "DEBUG";
1927     case DT_TEXTREL:    return "TEXTREL";
1928     case DT_JMPREL:     return "JMPREL";
1929     case DT_BIND_NOW:   return "BIND_NOW";
1930     case DT_INIT_ARRAY: return "INIT_ARRAY";
1931     case DT_FINI_ARRAY: return "FINI_ARRAY";
1932     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1934     case DT_RUNPATH:    return "RUNPATH";
1935     case DT_FLAGS:      return "FLAGS";
1936
1937     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1939
1940     case DT_CHECKSUM:   return "CHECKSUM";
1941     case DT_PLTPADSZ:   return "PLTPADSZ";
1942     case DT_MOVEENT:    return "MOVEENT";
1943     case DT_MOVESZ:     return "MOVESZ";
1944     case DT_FEATURE:    return "FEATURE";
1945     case DT_POSFLAG_1:  return "POSFLAG_1";
1946     case DT_SYMINSZ:    return "SYMINSZ";
1947     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1948
1949     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1950     case DT_CONFIG:     return "CONFIG";
1951     case DT_DEPAUDIT:   return "DEPAUDIT";
1952     case DT_AUDIT:      return "AUDIT";
1953     case DT_PLTPAD:     return "PLTPAD";
1954     case DT_MOVETAB:    return "MOVETAB";
1955     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1956
1957     case DT_VERSYM:     return "VERSYM";
1958
1959     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1961     case DT_RELACOUNT:  return "RELACOUNT";
1962     case DT_RELCOUNT:   return "RELCOUNT";
1963     case DT_FLAGS_1:    return "FLAGS_1";
1964     case DT_VERDEF:     return "VERDEF";
1965     case DT_VERDEFNUM:  return "VERDEFNUM";
1966     case DT_VERNEED:    return "VERNEED";
1967     case DT_VERNEEDNUM: return "VERNEEDNUM";
1968
1969     case DT_AUXILIARY:  return "AUXILIARY";
1970     case DT_USED:       return "USED";
1971     case DT_FILTER:     return "FILTER";
1972
1973     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1978     case DT_GNU_HASH:   return "GNU_HASH";
1979
1980     default:
1981       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982         {
1983           const char * result;
1984
1985           switch (elf_header.e_machine)
1986             {
1987             case EM_MIPS:
1988             case EM_MIPS_RS3_LE:
1989               result = get_mips_dynamic_type (type);
1990               break;
1991             case EM_SPARCV9:
1992               result = get_sparc64_dynamic_type (type);
1993               break;
1994             case EM_PPC:
1995               result = get_ppc_dynamic_type (type);
1996               break;
1997             case EM_PPC64:
1998               result = get_ppc64_dynamic_type (type);
1999               break;
2000             case EM_IA_64:
2001               result = get_ia64_dynamic_type (type);
2002               break;
2003             case EM_ALPHA:
2004               result = get_alpha_dynamic_type (type);
2005               break;
2006             case EM_SCORE:
2007               result = get_score_dynamic_type (type);
2008               break;
2009             case EM_TI_C6000:
2010               result = get_tic6x_dynamic_type (type);
2011               break;
2012             case EM_ALTERA_NIOS2:
2013               result = get_nios2_dynamic_type (type);
2014               break;
2015             default:
2016               result = NULL;
2017               break;
2018             }
2019
2020           if (result != NULL)
2021             return result;
2022
2023           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2024         }
2025       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026                || (elf_header.e_machine == EM_PARISC
2027                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2028         {
2029           const char * result;
2030
2031           switch (elf_header.e_machine)
2032             {
2033             case EM_PARISC:
2034               result = get_parisc_dynamic_type (type);
2035               break;
2036             case EM_IA_64:
2037               result = get_ia64_dynamic_type (type);
2038               break;
2039             default:
2040               result = NULL;
2041               break;
2042             }
2043
2044           if (result != NULL)
2045             return result;
2046
2047           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048                     type);
2049         }
2050       else
2051         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2052
2053       return buff;
2054     }
2055 }
2056
2057 static char *
2058 get_file_type (unsigned e_type)
2059 {
2060   static char buff[32];
2061
2062   switch (e_type)
2063     {
2064     case ET_NONE:       return _("NONE (None)");
2065     case ET_REL:        return _("REL (Relocatable file)");
2066     case ET_EXEC:       return _("EXEC (Executable file)");
2067     case ET_DYN:        return _("DYN (Shared object file)");
2068     case ET_CORE:       return _("CORE (Core file)");
2069
2070     default:
2071       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2072         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2073       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2074         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2075       else
2076         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2077       return buff;
2078     }
2079 }
2080
2081 static char *
2082 get_machine_name (unsigned e_machine)
2083 {
2084   static char buff[64]; /* XXX */
2085
2086   switch (e_machine)
2087     {
2088     case EM_NONE:               return _("None");
2089     case EM_AARCH64:            return "AArch64";
2090     case EM_M32:                return "WE32100";
2091     case EM_SPARC:              return "Sparc";
2092     case EM_SPU:                return "SPU";
2093     case EM_386:                return "Intel 80386";
2094     case EM_68K:                return "MC68000";
2095     case EM_88K:                return "MC88000";
2096     case EM_486:                return "Intel 80486";
2097     case EM_860:                return "Intel 80860";
2098     case EM_MIPS:               return "MIPS R3000";
2099     case EM_S370:               return "IBM System/370";
2100     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2101     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2102     case EM_PARISC:             return "HPPA";
2103     case EM_PPC_OLD:            return "Power PC (old)";
2104     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2105     case EM_960:                return "Intel 90860";
2106     case EM_PPC:                return "PowerPC";
2107     case EM_PPC64:              return "PowerPC64";
2108     case EM_FR20:               return "Fujitsu FR20";
2109     case EM_FT32:               return "FTDI FT32";
2110     case EM_RH32:               return "TRW RH32";
2111     case EM_MCORE:              return "MCORE";
2112     case EM_ARM:                return "ARM";
2113     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2114     case EM_SH:                 return "Renesas / SuperH SH";
2115     case EM_SPARCV9:            return "Sparc v9";
2116     case EM_TRICORE:            return "Siemens Tricore";
2117     case EM_ARC:                return "ARC";
2118     case EM_H8_300:             return "Renesas H8/300";
2119     case EM_H8_300H:            return "Renesas H8/300H";
2120     case EM_H8S:                return "Renesas H8S";
2121     case EM_H8_500:             return "Renesas H8/500";
2122     case EM_IA_64:              return "Intel IA-64";
2123     case EM_MIPS_X:             return "Stanford MIPS-X";
2124     case EM_COLDFIRE:           return "Motorola Coldfire";
2125     case EM_ALPHA:              return "Alpha";
2126     case EM_CYGNUS_D10V:
2127     case EM_D10V:               return "d10v";
2128     case EM_CYGNUS_D30V:
2129     case EM_D30V:               return "d30v";
2130     case EM_CYGNUS_M32R:
2131     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2132     case EM_CYGNUS_V850:
2133     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2134     case EM_V850:               return "Renesas V850";
2135     case EM_CYGNUS_MN10300:
2136     case EM_MN10300:            return "mn10300";
2137     case EM_CYGNUS_MN10200:
2138     case EM_MN10200:            return "mn10200";
2139     case EM_MOXIE:              return "Moxie";
2140     case EM_CYGNUS_FR30:
2141     case EM_FR30:               return "Fujitsu FR30";
2142     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2143     case EM_PJ_OLD:
2144     case EM_PJ:                 return "picoJava";
2145     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2146     case EM_PCP:                return "Siemens PCP";
2147     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2148     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2149     case EM_STARCORE:           return "Motorola Star*Core processor";
2150     case EM_ME16:               return "Toyota ME16 processor";
2151     case EM_ST100:              return "STMicroelectronics ST100 processor";
2152     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2153     case EM_PDSP:               return "Sony DSP processor";
2154     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2155     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2156     case EM_FX66:               return "Siemens FX66 microcontroller";
2157     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2159     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2160     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2161     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2162     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2163     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2164     case EM_SVX:                return "Silicon Graphics SVx";
2165     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2166     case EM_VAX:                return "Digital VAX";
2167     case EM_VISIUM:             return "CDS VISIUMcore processor";
2168     case EM_AVR_OLD:
2169     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2170     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2171     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2172     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2173     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2174     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2175     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2176     case EM_PRISM:              return "Vitesse Prism";
2177     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2178     case EM_L1OM:               return "Intel L1OM";
2179     case EM_K1OM:               return "Intel K1OM";
2180     case EM_S390_OLD:
2181     case EM_S390:               return "IBM S/390";
2182     case EM_SCORE:              return "SUNPLUS S+Core";
2183     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2184     case EM_OR1K:               return "OpenRISC 1000";
2185     case EM_ARC_A5:             return "ARC International ARCompact processor";
2186     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2187     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2188     case EM_DLX:                return "OpenDLX";
2189     case EM_IP2K_OLD:
2190     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2191     case EM_IQ2000:             return "Vitesse IQ2000";
2192     case EM_XTENSA_OLD:
2193     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2194     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2195     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2196     case EM_NS32K:              return "National Semiconductor 32000 series";
2197     case EM_TPC:                return "Tenor Network TPC processor";
2198     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2199     case EM_MAX:                return "MAX Processor";
2200     case EM_CR:                 return "National Semiconductor CompactRISC";
2201     case EM_F2MC16:             return "Fujitsu F2MC16";
2202     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2203     case EM_LATTICEMICO32:      return "Lattice Mico32";
2204     case EM_M32C_OLD:
2205     case EM_M32C:               return "Renesas M32c";
2206     case EM_MT:                 return "Morpho Techologies MT processor";
2207     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2208     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2209     case EM_SEP:                return "Sharp embedded microprocessor";
2210     case EM_ARCA:               return "Arca RISC microprocessor";
2211     case EM_UNICORE:            return "Unicore";
2212     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2213     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2214     case EM_NIOS32:             return "Altera Nios";
2215     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2216     case EM_C166:
2217     case EM_XC16X:              return "Infineon Technologies xc16x";
2218     case EM_M16C:               return "Renesas M16C series microprocessors";
2219     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2220     case EM_CE:                 return "Freescale Communication Engine RISC core";
2221     case EM_TSK3000:            return "Altium TSK3000 core";
2222     case EM_RS08:               return "Freescale RS08 embedded processor";
2223     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2224     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2225     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2226     case EM_SE_C17:             return "Seiko Epson C17 family";
2227     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2228     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2229     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2230     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2232     case EM_R32C:               return "Renesas R32C series microprocessors";
2233     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2234     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2235     case EM_8051:               return "Intel 8051 and variants";
2236     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2237     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2238     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2239     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2241     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2242     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2243     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2244     case EM_CR16:
2245     case EM_MICROBLAZE:
2246     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2247     case EM_RL78:               return "Renesas RL78";
2248     case EM_RX:                 return "Renesas RX";
2249     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2250     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2251     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2252     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2253     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2254     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2255     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2256     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2257     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2258     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2259     case EM_CUDA:               return "NVIDIA CUDA architecture";
2260     case EM_XGATE:              return "Motorola XGATE embedded processor";
2261     default:
2262       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2263       return buff;
2264     }
2265 }
2266
2267 static void
2268 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2269 {
2270   unsigned eabi;
2271   int unknown = 0;
2272
2273   eabi = EF_ARM_EABI_VERSION (e_flags);
2274   e_flags &= ~ EF_ARM_EABIMASK;
2275
2276   /* Handle "generic" ARM flags.  */
2277   if (e_flags & EF_ARM_RELEXEC)
2278     {
2279       strcat (buf, ", relocatable executable");
2280       e_flags &= ~ EF_ARM_RELEXEC;
2281     }
2282
2283   /* Now handle EABI specific flags.  */
2284   switch (eabi)
2285     {
2286     default:
2287       strcat (buf, ", <unrecognized EABI>");
2288       if (e_flags)
2289         unknown = 1;
2290       break;
2291
2292     case EF_ARM_EABI_VER1:
2293       strcat (buf, ", Version1 EABI");
2294       while (e_flags)
2295         {
2296           unsigned flag;
2297
2298           /* Process flags one bit at a time.  */
2299           flag = e_flags & - e_flags;
2300           e_flags &= ~ flag;
2301
2302           switch (flag)
2303             {
2304             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2305               strcat (buf, ", sorted symbol tables");
2306               break;
2307
2308             default:
2309               unknown = 1;
2310               break;
2311             }
2312         }
2313       break;
2314
2315     case EF_ARM_EABI_VER2:
2316       strcat (buf, ", Version2 EABI");
2317       while (e_flags)
2318         {
2319           unsigned flag;
2320
2321           /* Process flags one bit at a time.  */
2322           flag = e_flags & - e_flags;
2323           e_flags &= ~ flag;
2324
2325           switch (flag)
2326             {
2327             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2328               strcat (buf, ", sorted symbol tables");
2329               break;
2330
2331             case EF_ARM_DYNSYMSUSESEGIDX:
2332               strcat (buf, ", dynamic symbols use segment index");
2333               break;
2334
2335             case EF_ARM_MAPSYMSFIRST:
2336               strcat (buf, ", mapping symbols precede others");
2337               break;
2338
2339             default:
2340               unknown = 1;
2341               break;
2342             }
2343         }
2344       break;
2345
2346     case EF_ARM_EABI_VER3:
2347       strcat (buf, ", Version3 EABI");
2348       break;
2349
2350     case EF_ARM_EABI_VER4:
2351       strcat (buf, ", Version4 EABI");
2352       while (e_flags)
2353         {
2354           unsigned flag;
2355
2356           /* Process flags one bit at a time.  */
2357           flag = e_flags & - e_flags;
2358           e_flags &= ~ flag;
2359
2360           switch (flag)
2361             {
2362             case EF_ARM_BE8:
2363               strcat (buf, ", BE8");
2364               break;
2365
2366             case EF_ARM_LE8:
2367               strcat (buf, ", LE8");
2368               break;
2369
2370             default:
2371               unknown = 1;
2372               break;
2373             }
2374       break;
2375         }
2376       break;
2377
2378     case EF_ARM_EABI_VER5:
2379       strcat (buf, ", Version5 EABI");
2380       while (e_flags)
2381         {
2382           unsigned flag;
2383
2384           /* Process flags one bit at a time.  */
2385           flag = e_flags & - e_flags;
2386           e_flags &= ~ flag;
2387
2388           switch (flag)
2389             {
2390             case EF_ARM_BE8:
2391               strcat (buf, ", BE8");
2392               break;
2393
2394             case EF_ARM_LE8:
2395               strcat (buf, ", LE8");
2396               break;
2397
2398             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2399               strcat (buf, ", soft-float ABI");
2400               break;
2401
2402             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2403               strcat (buf, ", hard-float ABI");
2404               break;
2405
2406             default:
2407               unknown = 1;
2408               break;
2409             }
2410         }
2411       break;
2412
2413     case EF_ARM_EABI_UNKNOWN:
2414       strcat (buf, ", GNU EABI");
2415       while (e_flags)
2416         {
2417           unsigned flag;
2418
2419           /* Process flags one bit at a time.  */
2420           flag = e_flags & - e_flags;
2421           e_flags &= ~ flag;
2422
2423           switch (flag)
2424             {
2425             case EF_ARM_INTERWORK:
2426               strcat (buf, ", interworking enabled");
2427               break;
2428
2429             case EF_ARM_APCS_26:
2430               strcat (buf, ", uses APCS/26");
2431               break;
2432
2433             case EF_ARM_APCS_FLOAT:
2434               strcat (buf, ", uses APCS/float");
2435               break;
2436
2437             case EF_ARM_PIC:
2438               strcat (buf, ", position independent");
2439               break;
2440
2441             case EF_ARM_ALIGN8:
2442               strcat (buf, ", 8 bit structure alignment");
2443               break;
2444
2445             case EF_ARM_NEW_ABI:
2446               strcat (buf, ", uses new ABI");
2447               break;
2448
2449             case EF_ARM_OLD_ABI:
2450               strcat (buf, ", uses old ABI");
2451               break;
2452
2453             case EF_ARM_SOFT_FLOAT:
2454               strcat (buf, ", software FP");
2455               break;
2456
2457             case EF_ARM_VFP_FLOAT:
2458               strcat (buf, ", VFP");
2459               break;
2460
2461             case EF_ARM_MAVERICK_FLOAT:
2462               strcat (buf, ", Maverick FP");
2463               break;
2464
2465             default:
2466               unknown = 1;
2467               break;
2468             }
2469         }
2470     }
2471
2472   if (unknown)
2473     strcat (buf,_(", <unknown>"));
2474 }
2475
2476 static void
2477 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2478 {
2479   --size; /* Leave space for null terminator.  */
2480
2481   switch (e_flags & EF_AVR_MACH)
2482     {
2483     case E_AVR_MACH_AVR1:
2484       strncat (buf, ", avr:1", size);
2485       break;
2486     case E_AVR_MACH_AVR2:
2487       strncat (buf, ", avr:2", size);
2488       break;
2489     case E_AVR_MACH_AVR25:
2490       strncat (buf, ", avr:25", size);
2491       break;
2492     case E_AVR_MACH_AVR3:
2493       strncat (buf, ", avr:3", size);
2494       break;
2495     case E_AVR_MACH_AVR31:
2496       strncat (buf, ", avr:31", size);
2497       break;
2498     case E_AVR_MACH_AVR35:
2499       strncat (buf, ", avr:35", size);
2500       break;
2501     case E_AVR_MACH_AVR4:
2502       strncat (buf, ", avr:4", size);
2503       break;
2504     case E_AVR_MACH_AVR5:
2505       strncat (buf, ", avr:5", size);
2506       break;
2507     case E_AVR_MACH_AVR51:
2508       strncat (buf, ", avr:51", size);
2509       break;
2510     case E_AVR_MACH_AVR6:
2511       strncat (buf, ", avr:6", size);
2512       break;
2513     case E_AVR_MACH_AVRTINY:
2514       strncat (buf, ", avr:100", size);
2515       break;
2516     case E_AVR_MACH_XMEGA1:
2517       strncat (buf, ", avr:101", size);
2518       break;
2519     case E_AVR_MACH_XMEGA2:
2520       strncat (buf, ", avr:102", size);
2521       break;
2522     case E_AVR_MACH_XMEGA3:
2523       strncat (buf, ", avr:103", size);
2524       break;
2525     case E_AVR_MACH_XMEGA4:
2526       strncat (buf, ", avr:104", size);
2527       break;
2528     case E_AVR_MACH_XMEGA5:
2529       strncat (buf, ", avr:105", size);
2530       break;
2531     case E_AVR_MACH_XMEGA6:
2532       strncat (buf, ", avr:106", size);
2533       break;
2534     case E_AVR_MACH_XMEGA7:
2535       strncat (buf, ", avr:107", size);
2536       break;
2537     default:
2538       strncat (buf, ", avr:<unknown>", size);
2539       break;
2540     }
2541
2542   size -= strlen (buf);
2543   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2544     strncat (buf, ", link-relax", size);
2545 }
2546
2547 static void
2548 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2549 {
2550   unsigned abi;
2551   unsigned arch;
2552   unsigned config;
2553   unsigned version;
2554   int has_fpu = 0;
2555   int r = 0;
2556
2557   static const char *ABI_STRINGS[] =
2558   {
2559     "ABI v0", /* use r5 as return register; only used in N1213HC */
2560     "ABI v1", /* use r0 as return register */
2561     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562     "ABI v2fp", /* for FPU */
2563     "AABI",
2564     "ABI2 FP+"
2565   };
2566   static const char *VER_STRINGS[] =
2567   {
2568     "Andes ELF V1.3 or older",
2569     "Andes ELF V1.3.1",
2570     "Andes ELF V1.4"
2571   };
2572   static const char *ARCH_STRINGS[] =
2573   {
2574     "",
2575     "Andes Star v1.0",
2576     "Andes Star v2.0",
2577     "Andes Star v3.0",
2578     "Andes Star v3.0m"
2579   };
2580
2581   abi = EF_NDS_ABI & e_flags;
2582   arch = EF_NDS_ARCH & e_flags;
2583   config = EF_NDS_INST & e_flags;
2584   version = EF_NDS32_ELF_VERSION & e_flags;
2585
2586   memset (buf, 0, size);
2587
2588   switch (abi)
2589     {
2590     case E_NDS_ABI_V0:
2591     case E_NDS_ABI_V1:
2592     case E_NDS_ABI_V2:
2593     case E_NDS_ABI_V2FP:
2594     case E_NDS_ABI_AABI:
2595     case E_NDS_ABI_V2FP_PLUS:
2596       /* In case there are holes in the array.  */
2597       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2598       break;
2599
2600     default:
2601       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2602       break;
2603     }
2604
2605   switch (version)
2606     {
2607     case E_NDS32_ELF_VER_1_2:
2608     case E_NDS32_ELF_VER_1_3:
2609     case E_NDS32_ELF_VER_1_4:
2610       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2611       break;
2612
2613     default:
2614       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2615       break;
2616     }
2617
2618   if (E_NDS_ABI_V0 == abi)
2619     {
2620       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2621       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622       if (arch == E_NDS_ARCH_STAR_V1_0)
2623         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2624       return;
2625     }
2626
2627   switch (arch)
2628     {
2629     case E_NDS_ARCH_STAR_V1_0:
2630     case E_NDS_ARCH_STAR_V2_0:
2631     case E_NDS_ARCH_STAR_V3_0:
2632     case E_NDS_ARCH_STAR_V3_M:
2633       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2634       break;
2635
2636     default:
2637       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2638       /* ARCH version determines how the e_flags are interpreted.
2639          If it is unknown, we cannot proceed.  */
2640       return;
2641     }
2642
2643   /* Newer ABI; Now handle architecture specific flags.  */
2644   if (arch == E_NDS_ARCH_STAR_V1_0)
2645     {
2646       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2647         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2648
2649       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2650         r += snprintf (buf + r, size -r, ", MAC");
2651
2652       if (config & E_NDS32_HAS_DIV_INST)
2653         r += snprintf (buf + r, size -r, ", DIV");
2654
2655       if (config & E_NDS32_HAS_16BIT_INST)
2656         r += snprintf (buf + r, size -r, ", 16b");
2657     }
2658   else
2659     {
2660       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2661         {
2662           if (version <= E_NDS32_ELF_VER_1_3)
2663             r += snprintf (buf + r, size -r, ", [B8]");
2664           else
2665             r += snprintf (buf + r, size -r, ", EX9");
2666         }
2667
2668       if (config & E_NDS32_HAS_MAC_DX_INST)
2669         r += snprintf (buf + r, size -r, ", MAC_DX");
2670
2671       if (config & E_NDS32_HAS_DIV_DX_INST)
2672         r += snprintf (buf + r, size -r, ", DIV_DX");
2673
2674       if (config & E_NDS32_HAS_16BIT_INST)
2675         {
2676           if (version <= E_NDS32_ELF_VER_1_3)
2677             r += snprintf (buf + r, size -r, ", 16b");
2678           else
2679             r += snprintf (buf + r, size -r, ", IFC");
2680         }
2681     }
2682
2683   if (config & E_NDS32_HAS_EXT_INST)
2684     r += snprintf (buf + r, size -r, ", PERF1");
2685
2686   if (config & E_NDS32_HAS_EXT2_INST)
2687     r += snprintf (buf + r, size -r, ", PERF2");
2688
2689   if (config & E_NDS32_HAS_FPU_INST)
2690     {
2691       has_fpu = 1;
2692       r += snprintf (buf + r, size -r, ", FPU_SP");
2693     }
2694
2695   if (config & E_NDS32_HAS_FPU_DP_INST)
2696     {
2697       has_fpu = 1;
2698       r += snprintf (buf + r, size -r, ", FPU_DP");
2699     }
2700
2701   if (config & E_NDS32_HAS_FPU_MAC_INST)
2702     {
2703       has_fpu = 1;
2704       r += snprintf (buf + r, size -r, ", FPU_MAC");
2705     }
2706
2707   if (has_fpu)
2708     {
2709       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2710         {
2711         case E_NDS32_FPU_REG_8SP_4DP:
2712           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2713           break;
2714         case E_NDS32_FPU_REG_16SP_8DP:
2715           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2716           break;
2717         case E_NDS32_FPU_REG_32SP_16DP:
2718           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2719           break;
2720         case E_NDS32_FPU_REG_32SP_32DP:
2721           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2722           break;
2723         }
2724     }
2725
2726   if (config & E_NDS32_HAS_AUDIO_INST)
2727     r += snprintf (buf + r, size -r, ", AUDIO");
2728
2729   if (config & E_NDS32_HAS_STRING_INST)
2730     r += snprintf (buf + r, size -r, ", STR");
2731
2732   if (config & E_NDS32_HAS_REDUCED_REGS)
2733     r += snprintf (buf + r, size -r, ", 16REG");
2734
2735   if (config & E_NDS32_HAS_VIDEO_INST)
2736     {
2737       if (version <= E_NDS32_ELF_VER_1_3)
2738         r += snprintf (buf + r, size -r, ", VIDEO");
2739       else
2740         r += snprintf (buf + r, size -r, ", SATURATION");
2741     }
2742
2743   if (config & E_NDS32_HAS_ENCRIPT_INST)
2744     r += snprintf (buf + r, size -r, ", ENCRP");
2745
2746   if (config & E_NDS32_HAS_L2C_INST)
2747     r += snprintf (buf + r, size -r, ", L2C");
2748 }
2749
2750 static char *
2751 get_machine_flags (unsigned e_flags, unsigned e_machine)
2752 {
2753   static char buf[1024];
2754
2755   buf[0] = '\0';
2756
2757   if (e_flags)
2758     {
2759       switch (e_machine)
2760         {
2761         default:
2762           break;
2763
2764         case EM_ARM:
2765           decode_ARM_machine_flags (e_flags, buf);
2766           break;
2767
2768         case EM_AVR:
2769           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2770           break;
2771
2772         case EM_BLACKFIN:
2773           if (e_flags & EF_BFIN_PIC)
2774             strcat (buf, ", PIC");
2775
2776           if (e_flags & EF_BFIN_FDPIC)
2777             strcat (buf, ", FDPIC");
2778
2779           if (e_flags & EF_BFIN_CODE_IN_L1)
2780             strcat (buf, ", code in L1");
2781
2782           if (e_flags & EF_BFIN_DATA_IN_L1)
2783             strcat (buf, ", data in L1");
2784
2785           break;
2786
2787         case EM_CYGNUS_FRV:
2788           switch (e_flags & EF_FRV_CPU_MASK)
2789             {
2790             case EF_FRV_CPU_GENERIC:
2791               break;
2792
2793             default:
2794               strcat (buf, ", fr???");
2795               break;
2796
2797             case EF_FRV_CPU_FR300:
2798               strcat (buf, ", fr300");
2799               break;
2800
2801             case EF_FRV_CPU_FR400:
2802               strcat (buf, ", fr400");
2803               break;
2804             case EF_FRV_CPU_FR405:
2805               strcat (buf, ", fr405");
2806               break;
2807
2808             case EF_FRV_CPU_FR450:
2809               strcat (buf, ", fr450");
2810               break;
2811
2812             case EF_FRV_CPU_FR500:
2813               strcat (buf, ", fr500");
2814               break;
2815             case EF_FRV_CPU_FR550:
2816               strcat (buf, ", fr550");
2817               break;
2818
2819             case EF_FRV_CPU_SIMPLE:
2820               strcat (buf, ", simple");
2821               break;
2822             case EF_FRV_CPU_TOMCAT:
2823               strcat (buf, ", tomcat");
2824               break;
2825             }
2826           break;
2827
2828         case EM_68K:
2829           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2830             strcat (buf, ", m68000");
2831           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2832             strcat (buf, ", cpu32");
2833           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2834             strcat (buf, ", fido_a");
2835           else
2836             {
2837               char const * isa = _("unknown");
2838               char const * mac = _("unknown mac");
2839               char const * additional = NULL;
2840
2841               switch (e_flags & EF_M68K_CF_ISA_MASK)
2842                 {
2843                 case EF_M68K_CF_ISA_A_NODIV:
2844                   isa = "A";
2845                   additional = ", nodiv";
2846                   break;
2847                 case EF_M68K_CF_ISA_A:
2848                   isa = "A";
2849                   break;
2850                 case EF_M68K_CF_ISA_A_PLUS:
2851                   isa = "A+";
2852                   break;
2853                 case EF_M68K_CF_ISA_B_NOUSP:
2854                   isa = "B";
2855                   additional = ", nousp";
2856                   break;
2857                 case EF_M68K_CF_ISA_B:
2858                   isa = "B";
2859                   break;
2860                 case EF_M68K_CF_ISA_C:
2861                   isa = "C";
2862                   break;
2863                 case EF_M68K_CF_ISA_C_NODIV:
2864                   isa = "C";
2865                   additional = ", nodiv";
2866                   break;
2867                 }
2868               strcat (buf, ", cf, isa ");
2869               strcat (buf, isa);
2870               if (additional)
2871                 strcat (buf, additional);
2872               if (e_flags & EF_M68K_CF_FLOAT)
2873                 strcat (buf, ", float");
2874               switch (e_flags & EF_M68K_CF_MAC_MASK)
2875                 {
2876                 case 0:
2877                   mac = NULL;
2878                   break;
2879                 case EF_M68K_CF_MAC:
2880                   mac = "mac";
2881                   break;
2882                 case EF_M68K_CF_EMAC:
2883                   mac = "emac";
2884                   break;
2885                 case EF_M68K_CF_EMAC_B:
2886                   mac = "emac_b";
2887                   break;
2888                 }
2889               if (mac)
2890                 {
2891                   strcat (buf, ", ");
2892                   strcat (buf, mac);
2893                 }
2894             }
2895           break;
2896
2897         case EM_PPC:
2898           if (e_flags & EF_PPC_EMB)
2899             strcat (buf, ", emb");
2900
2901           if (e_flags & EF_PPC_RELOCATABLE)
2902             strcat (buf, _(", relocatable"));
2903
2904           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2905             strcat (buf, _(", relocatable-lib"));
2906           break;
2907
2908         case EM_PPC64:
2909           if (e_flags & EF_PPC64_ABI)
2910             {
2911               char abi[] = ", abiv0";
2912
2913               abi[6] += e_flags & EF_PPC64_ABI;
2914               strcat (buf, abi);
2915             }
2916           break;
2917
2918         case EM_V800:
2919           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2920             strcat (buf, ", RH850 ABI");
2921
2922           if (e_flags & EF_V800_850E3)
2923             strcat (buf, ", V3 architecture");
2924
2925           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2926             strcat (buf, ", FPU not used");
2927
2928           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2929             strcat (buf, ", regmode: COMMON");
2930
2931           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2932             strcat (buf, ", r4 not used");
2933
2934           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2935             strcat (buf, ", r30 not used");
2936
2937           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2938             strcat (buf, ", r5 not used");
2939
2940           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2941             strcat (buf, ", r2 not used");
2942
2943           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2944             {
2945               switch (e_flags & - e_flags)
2946                 {
2947                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2948                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2949                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2950                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2951                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2952                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2953                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2954                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2955                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2956                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2957                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2958                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2959                 default: break;
2960                 }
2961             }
2962           break;
2963
2964         case EM_V850:
2965         case EM_CYGNUS_V850:
2966           switch (e_flags & EF_V850_ARCH)
2967             {
2968             case E_V850E3V5_ARCH:
2969               strcat (buf, ", v850e3v5");
2970               break;
2971             case E_V850E2V3_ARCH:
2972               strcat (buf, ", v850e2v3");
2973               break;
2974             case E_V850E2_ARCH:
2975               strcat (buf, ", v850e2");
2976               break;
2977             case E_V850E1_ARCH:
2978               strcat (buf, ", v850e1");
2979               break;
2980             case E_V850E_ARCH:
2981               strcat (buf, ", v850e");
2982               break;
2983             case E_V850_ARCH:
2984               strcat (buf, ", v850");
2985               break;
2986             default:
2987               strcat (buf, _(", unknown v850 architecture variant"));
2988               break;
2989             }
2990           break;
2991
2992         case EM_M32R:
2993         case EM_CYGNUS_M32R:
2994           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2995             strcat (buf, ", m32r");
2996           break;
2997
2998         case EM_MIPS:
2999         case EM_MIPS_RS3_LE:
3000           if (e_flags & EF_MIPS_NOREORDER)
3001             strcat (buf, ", noreorder");
3002
3003           if (e_flags & EF_MIPS_PIC)
3004             strcat (buf, ", pic");
3005
3006           if (e_flags & EF_MIPS_CPIC)
3007             strcat (buf, ", cpic");
3008
3009           if (e_flags & EF_MIPS_UCODE)
3010             strcat (buf, ", ugen_reserved");
3011
3012           if (e_flags & EF_MIPS_ABI2)
3013             strcat (buf, ", abi2");
3014
3015           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3016             strcat (buf, ", odk first");
3017
3018           if (e_flags & EF_MIPS_32BITMODE)
3019             strcat (buf, ", 32bitmode");
3020
3021           if (e_flags & EF_MIPS_NAN2008)
3022             strcat (buf, ", nan2008");
3023
3024           if (e_flags & EF_MIPS_FP64)
3025             strcat (buf, ", fp64");
3026
3027           switch ((e_flags & EF_MIPS_MACH))
3028             {
3029             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3030             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3031             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3032             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3033             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3034             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3035             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3036             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3037             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3038             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3039             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3040             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3041             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3042             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3043             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3044             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3045             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3046             case 0:
3047             /* We simply ignore the field in this case to avoid confusion:
3048                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3049                extension.  */
3050               break;
3051             default: strcat (buf, _(", unknown CPU")); break;
3052             }
3053
3054           switch ((e_flags & EF_MIPS_ABI))
3055             {
3056             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3057             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3058             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3059             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3060             case 0:
3061             /* We simply ignore the field in this case to avoid confusion:
3062                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3063                This means it is likely to be an o32 file, but not for
3064                sure.  */
3065               break;
3066             default: strcat (buf, _(", unknown ABI")); break;
3067             }
3068
3069           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3070             strcat (buf, ", mdmx");
3071
3072           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3073             strcat (buf, ", mips16");
3074
3075           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3076             strcat (buf, ", micromips");
3077
3078           switch ((e_flags & EF_MIPS_ARCH))
3079             {
3080             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3081             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3082             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3083             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3084             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3085             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3086             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3087             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3088             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3089             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3090             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3091             default: strcat (buf, _(", unknown ISA")); break;
3092             }
3093           break;
3094
3095         case EM_NDS32:
3096           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3097           break;
3098
3099         case EM_SH:
3100           switch ((e_flags & EF_SH_MACH_MASK))
3101             {
3102             case EF_SH1: strcat (buf, ", sh1"); break;
3103             case EF_SH2: strcat (buf, ", sh2"); break;
3104             case EF_SH3: strcat (buf, ", sh3"); break;
3105             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3106             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3107             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3108             case EF_SH3E: strcat (buf, ", sh3e"); break;
3109             case EF_SH4: strcat (buf, ", sh4"); break;
3110             case EF_SH5: strcat (buf, ", sh5"); break;
3111             case EF_SH2E: strcat (buf, ", sh2e"); break;
3112             case EF_SH4A: strcat (buf, ", sh4a"); break;
3113             case EF_SH2A: strcat (buf, ", sh2a"); break;
3114             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3115             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3116             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3117             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3118             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3119             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3120             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3121             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3122             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3123             default: strcat (buf, _(", unknown ISA")); break;
3124             }
3125
3126           if (e_flags & EF_SH_PIC)
3127             strcat (buf, ", pic");
3128
3129           if (e_flags & EF_SH_FDPIC)
3130             strcat (buf, ", fdpic");
3131           break;
3132
3133         case EM_OR1K:
3134           if (e_flags & EF_OR1K_NODELAY)
3135             strcat (buf, ", no delay");
3136           break;
3137
3138         case EM_SPARCV9:
3139           if (e_flags & EF_SPARC_32PLUS)
3140             strcat (buf, ", v8+");
3141
3142           if (e_flags & EF_SPARC_SUN_US1)
3143             strcat (buf, ", ultrasparcI");
3144
3145           if (e_flags & EF_SPARC_SUN_US3)
3146             strcat (buf, ", ultrasparcIII");
3147
3148           if (e_flags & EF_SPARC_HAL_R1)
3149             strcat (buf, ", halr1");
3150
3151           if (e_flags & EF_SPARC_LEDATA)
3152             strcat (buf, ", ledata");
3153
3154           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3155             strcat (buf, ", tso");
3156
3157           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3158             strcat (buf, ", pso");
3159
3160           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3161             strcat (buf, ", rmo");
3162           break;
3163
3164         case EM_PARISC:
3165           switch (e_flags & EF_PARISC_ARCH)
3166             {
3167             case EFA_PARISC_1_0:
3168               strcpy (buf, ", PA-RISC 1.0");
3169               break;
3170             case EFA_PARISC_1_1:
3171               strcpy (buf, ", PA-RISC 1.1");
3172               break;
3173             case EFA_PARISC_2_0:
3174               strcpy (buf, ", PA-RISC 2.0");
3175               break;
3176             default:
3177               break;
3178             }
3179           if (e_flags & EF_PARISC_TRAPNIL)
3180             strcat (buf, ", trapnil");
3181           if (e_flags & EF_PARISC_EXT)
3182             strcat (buf, ", ext");
3183           if (e_flags & EF_PARISC_LSB)
3184             strcat (buf, ", lsb");
3185           if (e_flags & EF_PARISC_WIDE)
3186             strcat (buf, ", wide");
3187           if (e_flags & EF_PARISC_NO_KABP)
3188             strcat (buf, ", no kabp");
3189           if (e_flags & EF_PARISC_LAZYSWAP)
3190             strcat (buf, ", lazyswap");
3191           break;
3192
3193         case EM_PJ:
3194         case EM_PJ_OLD:
3195           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3196             strcat (buf, ", new calling convention");
3197
3198           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3199             strcat (buf, ", gnu calling convention");
3200           break;
3201
3202         case EM_IA_64:
3203           if ((e_flags & EF_IA_64_ABI64))
3204             strcat (buf, ", 64-bit");
3205           else
3206             strcat (buf, ", 32-bit");
3207           if ((e_flags & EF_IA_64_REDUCEDFP))
3208             strcat (buf, ", reduced fp model");
3209           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3210             strcat (buf, ", no function descriptors, constant gp");
3211           else if ((e_flags & EF_IA_64_CONS_GP))
3212             strcat (buf, ", constant gp");
3213           if ((e_flags & EF_IA_64_ABSOLUTE))
3214             strcat (buf, ", absolute");
3215           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3216             {
3217               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3218                 strcat (buf, ", vms_linkages");
3219               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3220                 {
3221                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3222                   break;
3223                 case EF_IA_64_VMS_COMCOD_WARNING:
3224                   strcat (buf, ", warning");
3225                   break;
3226                 case EF_IA_64_VMS_COMCOD_ERROR:
3227                   strcat (buf, ", error");
3228                   break;
3229                 case EF_IA_64_VMS_COMCOD_ABORT:
3230                   strcat (buf, ", abort");
3231                   break;
3232                 default:
3233                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3234                         e_flags & EF_IA_64_VMS_COMCOD);
3235                   strcat (buf, ", <unknown>");
3236                 }
3237             }
3238           break;
3239
3240         case EM_VAX:
3241           if ((e_flags & EF_VAX_NONPIC))
3242             strcat (buf, ", non-PIC");
3243           if ((e_flags & EF_VAX_DFLOAT))
3244             strcat (buf, ", D-Float");
3245           if ((e_flags & EF_VAX_GFLOAT))
3246             strcat (buf, ", G-Float");
3247           break;
3248
3249         case EM_VISIUM:
3250           if (e_flags & EF_VISIUM_ARCH_MCM)
3251             strcat (buf, ", mcm");
3252           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3253             strcat (buf, ", mcm24");
3254           if (e_flags & EF_VISIUM_ARCH_GR6)
3255             strcat (buf, ", gr6");
3256           break;
3257
3258         case EM_RL78:
3259           if (e_flags & E_FLAG_RL78_G10)
3260             strcat (buf, ", G10");
3261           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3262             strcat (buf, ", 64-bit doubles");
3263           break;
3264
3265         case EM_RX:
3266           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3267             strcat (buf, ", 64-bit doubles");
3268           if (e_flags & E_FLAG_RX_DSP)
3269             strcat (buf, ", dsp");
3270           if (e_flags & E_FLAG_RX_PID)
3271             strcat (buf, ", pid");
3272           if (e_flags & E_FLAG_RX_ABI)
3273             strcat (buf, ", RX ABI");
3274           break;
3275
3276         case EM_S390:
3277           if (e_flags & EF_S390_HIGH_GPRS)
3278             strcat (buf, ", highgprs");
3279           break;
3280
3281         case EM_TI_C6000:
3282           if ((e_flags & EF_C6000_REL))
3283             strcat (buf, ", relocatable module");
3284           break;
3285
3286         case EM_MSP430:
3287           strcat (buf, _(": architecture variant: "));
3288           switch (e_flags & EF_MSP430_MACH)
3289             {
3290             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3291             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3292             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3293             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3294             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3295             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3296             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3297             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3298             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3299             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3300             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3301             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3302             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3303             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3304             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3305             default:
3306               strcat (buf, _(": unknown")); break;
3307             }
3308
3309           if (e_flags & ~ EF_MSP430_MACH)
3310             strcat (buf, _(": unknown extra flag bits also present"));
3311         }
3312     }
3313
3314   return buf;
3315 }
3316
3317 static const char *
3318 get_osabi_name (unsigned int osabi)
3319 {
3320   static char buff[32];
3321
3322   switch (osabi)
3323     {
3324     case ELFOSABI_NONE:         return "UNIX - System V";
3325     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3326     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3327     case ELFOSABI_GNU:          return "UNIX - GNU";
3328     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3329     case ELFOSABI_AIX:          return "UNIX - AIX";
3330     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3331     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3332     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3333     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3334     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3335     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3336     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3337     case ELFOSABI_AROS:         return "AROS";
3338     case ELFOSABI_FENIXOS:      return "FenixOS";
3339     default:
3340       if (osabi >= 64)
3341         switch (elf_header.e_machine)
3342           {
3343           case EM_ARM:
3344             switch (osabi)
3345               {
3346               case ELFOSABI_ARM:        return "ARM";
3347               default:
3348                 break;
3349               }
3350             break;
3351
3352           case EM_MSP430:
3353           case EM_MSP430_OLD:
3354           case EM_VISIUM:
3355             switch (osabi)
3356               {
3357               case ELFOSABI_STANDALONE: return _("Standalone App");
3358               default:
3359                 break;
3360               }
3361             break;
3362
3363           case EM_TI_C6000:
3364             switch (osabi)
3365               {
3366               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3367               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3368               default:
3369                 break;
3370               }
3371             break;
3372
3373           default:
3374             break;
3375           }
3376       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3377       return buff;
3378     }
3379 }
3380
3381 static const char *
3382 get_aarch64_segment_type (unsigned long type)
3383 {
3384   switch (type)
3385     {
3386     case PT_AARCH64_ARCHEXT:
3387       return "AARCH64_ARCHEXT";
3388     default:
3389       break;
3390     }
3391
3392   return NULL;
3393 }
3394
3395 static const char *
3396 get_arm_segment_type (unsigned long type)
3397 {
3398   switch (type)
3399     {
3400     case PT_ARM_EXIDX:
3401       return "EXIDX";
3402     default:
3403       break;
3404     }
3405
3406   return NULL;
3407 }
3408
3409 static const char *
3410 get_mips_segment_type (unsigned long type)
3411 {
3412   switch (type)
3413     {
3414     case PT_MIPS_REGINFO:
3415       return "REGINFO";
3416     case PT_MIPS_RTPROC:
3417       return "RTPROC";
3418     case PT_MIPS_OPTIONS:
3419       return "OPTIONS";
3420     case PT_MIPS_ABIFLAGS:
3421       return "ABIFLAGS";
3422     default:
3423       break;
3424     }
3425
3426   return NULL;
3427 }
3428
3429 static const char *
3430 get_parisc_segment_type (unsigned long type)
3431 {
3432   switch (type)
3433     {
3434     case PT_HP_TLS:             return "HP_TLS";
3435     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3436     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3437     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3438     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3439     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3440     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3441     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3442     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3443     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3444     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3445     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3446     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3447     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3448     case PT_HP_STACK:           return "HP_STACK";
3449     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3450     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3451     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3452     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3453     default:
3454       break;
3455     }
3456
3457   return NULL;
3458 }
3459
3460 static const char *
3461 get_ia64_segment_type (unsigned long type)
3462 {
3463   switch (type)
3464     {
3465     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3466     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3467     case PT_HP_TLS:             return "HP_TLS";
3468     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3469     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3470     case PT_IA_64_HP_STACK:     return "HP_STACK";
3471     default:
3472       break;
3473     }
3474
3475   return NULL;
3476 }
3477
3478 static const char *
3479 get_tic6x_segment_type (unsigned long type)
3480 {
3481   switch (type)
3482     {
3483     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3484     default:
3485       break;
3486     }
3487
3488   return NULL;
3489 }
3490
3491 static const char *
3492 get_segment_type (unsigned long p_type)
3493 {
3494   static char buff[32];
3495
3496   switch (p_type)
3497     {
3498     case PT_NULL:       return "NULL";
3499     case PT_LOAD:       return "LOAD";
3500     case PT_DYNAMIC:    return "DYNAMIC";
3501     case PT_INTERP:     return "INTERP";
3502     case PT_NOTE:       return "NOTE";
3503     case PT_SHLIB:      return "SHLIB";
3504     case PT_PHDR:       return "PHDR";
3505     case PT_TLS:        return "TLS";
3506
3507     case PT_GNU_EH_FRAME:
3508                         return "GNU_EH_FRAME";
3509     case PT_GNU_STACK:  return "GNU_STACK";
3510     case PT_GNU_RELRO:  return "GNU_RELRO";
3511
3512     default:
3513       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3514         {
3515           const char * result;
3516
3517           switch (elf_header.e_machine)
3518             {
3519             case EM_AARCH64:
3520               result = get_aarch64_segment_type (p_type);
3521               break;
3522             case EM_ARM:
3523               result = get_arm_segment_type (p_type);
3524               break;
3525             case EM_MIPS:
3526             case EM_MIPS_RS3_LE:
3527               result = get_mips_segment_type (p_type);
3528               break;
3529             case EM_PARISC:
3530               result = get_parisc_segment_type (p_type);
3531               break;
3532             case EM_IA_64:
3533               result = get_ia64_segment_type (p_type);
3534               break;
3535             case EM_TI_C6000:
3536               result = get_tic6x_segment_type (p_type);
3537               break;
3538             default:
3539               result = NULL;
3540               break;
3541             }
3542
3543           if (result != NULL)
3544             return result;
3545
3546           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3547         }
3548       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3549         {
3550           const char * result;
3551
3552           switch (elf_header.e_machine)
3553             {
3554             case EM_PARISC:
3555               result = get_parisc_segment_type (p_type);
3556               break;
3557             case EM_IA_64:
3558               result = get_ia64_segment_type (p_type);
3559               break;
3560             default:
3561               result = NULL;
3562               break;
3563             }
3564
3565           if (result != NULL)
3566             return result;
3567
3568           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3569         }
3570       else
3571         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3572
3573       return buff;
3574     }
3575 }
3576
3577 static const char *
3578 get_mips_section_type_name (unsigned int sh_type)
3579 {
3580   switch (sh_type)
3581     {
3582     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3583     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3584     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3585     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3586     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3587     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3588     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3589     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3590     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3591     case SHT_MIPS_RELD:          return "MIPS_RELD";
3592     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3593     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3594     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3595     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3596     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3597     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3598     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3599     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3600     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3601     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3602     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3603     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3604     case SHT_MIPS_LINE:          return "MIPS_LINE";
3605     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3606     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3607     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3608     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3609     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3610     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3611     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3612     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3613     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3614     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3615     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3616     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3617     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3618     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3619     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3620     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3621     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3622     default:
3623       break;
3624     }
3625   return NULL;
3626 }
3627
3628 static const char *
3629 get_parisc_section_type_name (unsigned int sh_type)
3630 {
3631   switch (sh_type)
3632     {
3633     case SHT_PARISC_EXT:        return "PARISC_EXT";
3634     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3635     case SHT_PARISC_DOC:        return "PARISC_DOC";
3636     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3637     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3638     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3639     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3640     default:
3641       break;
3642     }
3643   return NULL;
3644 }
3645
3646 static const char *
3647 get_ia64_section_type_name (unsigned int sh_type)
3648 {
3649   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3650   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3651     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3652
3653   switch (sh_type)
3654     {
3655     case SHT_IA_64_EXT:                return "IA_64_EXT";
3656     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3657     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3658     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3659     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3660     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3661     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3662     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3663     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3664     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3665     default:
3666       break;
3667     }
3668   return NULL;
3669 }
3670
3671 static const char *
3672 get_x86_64_section_type_name (unsigned int sh_type)
3673 {
3674   switch (sh_type)
3675     {
3676     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3677     default:
3678       break;
3679     }
3680   return NULL;
3681 }
3682
3683 static const char *
3684 get_aarch64_section_type_name (unsigned int sh_type)
3685 {
3686   switch (sh_type)
3687     {
3688     case SHT_AARCH64_ATTRIBUTES:
3689       return "AARCH64_ATTRIBUTES";
3690     default:
3691       break;
3692     }
3693   return NULL;
3694 }
3695
3696 static const char *
3697 get_arm_section_type_name (unsigned int sh_type)
3698 {
3699   switch (sh_type)
3700     {
3701     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3702     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3703     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3704     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3705     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3706     default:
3707       break;
3708     }
3709   return NULL;
3710 }
3711
3712 static const char *
3713 get_tic6x_section_type_name (unsigned int sh_type)
3714 {
3715   switch (sh_type)
3716     {
3717     case SHT_C6000_UNWIND:
3718       return "C6000_UNWIND";
3719     case SHT_C6000_PREEMPTMAP:
3720       return "C6000_PREEMPTMAP";
3721     case SHT_C6000_ATTRIBUTES:
3722       return "C6000_ATTRIBUTES";
3723     case SHT_TI_ICODE:
3724       return "TI_ICODE";
3725     case SHT_TI_XREF:
3726       return "TI_XREF";
3727     case SHT_TI_HANDLER:
3728       return "TI_HANDLER";
3729     case SHT_TI_INITINFO:
3730       return "TI_INITINFO";
3731     case SHT_TI_PHATTRS:
3732       return "TI_PHATTRS";
3733     default:
3734       break;
3735     }
3736   return NULL;
3737 }
3738
3739 static const char *
3740 get_msp430x_section_type_name (unsigned int sh_type)
3741 {
3742   switch (sh_type)
3743     {
3744     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3745     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3746     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3747     default: return NULL;
3748     }
3749 }
3750
3751 static const char *
3752 get_v850_section_type_name (unsigned int sh_type)
3753 {
3754   switch (sh_type)
3755     {
3756     case SHT_V850_SCOMMON: return "V850 Small Common";
3757     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3758     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3759     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3760     case SHT_RENESAS_INFO: return "RENESAS INFO";
3761     default: return NULL;
3762     }
3763 }
3764
3765 static const char *
3766 get_section_type_name (unsigned int sh_type)
3767 {
3768   static char buff[32];
3769
3770   switch (sh_type)
3771     {
3772     case SHT_NULL:              return "NULL";
3773     case SHT_PROGBITS:          return "PROGBITS";
3774     case SHT_SYMTAB:            return "SYMTAB";
3775     case SHT_STRTAB:            return "STRTAB";
3776     case SHT_RELA:              return "RELA";
3777     case SHT_HASH:              return "HASH";
3778     case SHT_DYNAMIC:           return "DYNAMIC";
3779     case SHT_NOTE:              return "NOTE";
3780     case SHT_NOBITS:            return "NOBITS";
3781     case SHT_REL:               return "REL";
3782     case SHT_SHLIB:             return "SHLIB";
3783     case SHT_DYNSYM:            return "DYNSYM";
3784     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3785     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3786     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3787     case SHT_GNU_HASH:          return "GNU_HASH";
3788     case SHT_GROUP:             return "GROUP";
3789     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3790     case SHT_GNU_verdef:        return "VERDEF";
3791     case SHT_GNU_verneed:       return "VERNEED";
3792     case SHT_GNU_versym:        return "VERSYM";
3793     case 0x6ffffff0:            return "VERSYM";
3794     case 0x6ffffffc:            return "VERDEF";
3795     case 0x7ffffffd:            return "AUXILIARY";
3796     case 0x7fffffff:            return "FILTER";
3797     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3798
3799     default:
3800       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3801         {
3802           const char * result;
3803
3804           switch (elf_header.e_machine)
3805             {
3806             case EM_MIPS:
3807             case EM_MIPS_RS3_LE:
3808               result = get_mips_section_type_name (sh_type);
3809               break;
3810             case EM_PARISC:
3811               result = get_parisc_section_type_name (sh_type);
3812               break;
3813             case EM_IA_64:
3814               result = get_ia64_section_type_name (sh_type);
3815               break;
3816             case EM_X86_64:
3817             case EM_L1OM:
3818             case EM_K1OM:
3819               result = get_x86_64_section_type_name (sh_type);
3820               break;
3821             case EM_AARCH64:
3822               result = get_aarch64_section_type_name (sh_type);
3823               break;
3824             case EM_ARM:
3825               result = get_arm_section_type_name (sh_type);
3826               break;
3827             case EM_TI_C6000:
3828               result = get_tic6x_section_type_name (sh_type);
3829               break;
3830             case EM_MSP430:
3831               result = get_msp430x_section_type_name (sh_type);
3832               break;
3833             case EM_V800:
3834             case EM_V850:
3835             case EM_CYGNUS_V850:
3836               result = get_v850_section_type_name (sh_type);
3837               break;
3838             default:
3839               result = NULL;
3840               break;
3841             }
3842
3843           if (result != NULL)
3844             return result;
3845
3846           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3847         }
3848       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3849         {
3850           const char * result;
3851
3852           switch (elf_header.e_machine)
3853             {
3854             case EM_IA_64:
3855               result = get_ia64_section_type_name (sh_type);
3856               break;
3857             default:
3858               result = NULL;
3859               break;
3860             }
3861
3862           if (result != NULL)
3863             return result;
3864
3865           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3866         }
3867       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3868         {
3869           switch (elf_header.e_machine)
3870             {
3871             case EM_V800:
3872             case EM_V850:
3873             case EM_CYGNUS_V850:
3874               return get_v850_section_type_name (sh_type);
3875             default:
3876               break;
3877             }
3878
3879           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3880         }
3881       else
3882         /* This message is probably going to be displayed in a 15
3883            character wide field, so put the hex value first.  */
3884         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3885
3886       return buff;
3887     }
3888 }
3889
3890 #define OPTION_DEBUG_DUMP       512
3891 #define OPTION_DYN_SYMS         513
3892 #define OPTION_DWARF_DEPTH      514
3893 #define OPTION_DWARF_START      515
3894 #define OPTION_DWARF_CHECK      516
3895
3896 static struct option options[] =
3897 {
3898   {"all",              no_argument, 0, 'a'},
3899   {"file-header",      no_argument, 0, 'h'},
3900   {"program-headers",  no_argument, 0, 'l'},
3901   {"headers",          no_argument, 0, 'e'},
3902   {"histogram",        no_argument, 0, 'I'},
3903   {"segments",         no_argument, 0, 'l'},
3904   {"sections",         no_argument, 0, 'S'},
3905   {"section-headers",  no_argument, 0, 'S'},
3906   {"section-groups",   no_argument, 0, 'g'},
3907   {"section-details",  no_argument, 0, 't'},
3908   {"full-section-name",no_argument, 0, 'N'},
3909   {"symbols",          no_argument, 0, 's'},
3910   {"syms",             no_argument, 0, 's'},
3911   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3912   {"relocs",           no_argument, 0, 'r'},
3913   {"notes",            no_argument, 0, 'n'},
3914   {"dynamic",          no_argument, 0, 'd'},
3915   {"arch-specific",    no_argument, 0, 'A'},
3916   {"version-info",     no_argument, 0, 'V'},
3917   {"use-dynamic",      no_argument, 0, 'D'},
3918   {"unwind",           no_argument, 0, 'u'},
3919   {"archive-index",    no_argument, 0, 'c'},
3920   {"hex-dump",         required_argument, 0, 'x'},
3921   {"relocated-dump",   required_argument, 0, 'R'},
3922   {"string-dump",      required_argument, 0, 'p'},
3923 #ifdef SUPPORT_DISASSEMBLY
3924   {"instruction-dump", required_argument, 0, 'i'},
3925 #endif
3926   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3927
3928   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3929   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3930   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3931
3932   {"version",          no_argument, 0, 'v'},
3933   {"wide",             no_argument, 0, 'W'},
3934   {"help",             no_argument, 0, 'H'},
3935   {0,                  no_argument, 0, 0}
3936 };
3937
3938 static void
3939 usage (FILE * stream)
3940 {
3941   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3942   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3943   fprintf (stream, _(" Options are:\n\
3944   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3945   -h --file-header       Display the ELF file header\n\
3946   -l --program-headers   Display the program headers\n\
3947      --segments          An alias for --program-headers\n\
3948   -S --section-headers   Display the sections' header\n\
3949      --sections          An alias for --section-headers\n\
3950   -g --section-groups    Display the section groups\n\
3951   -t --section-details   Display the section details\n\
3952   -e --headers           Equivalent to: -h -l -S\n\
3953   -s --syms              Display the symbol table\n\
3954      --symbols           An alias for --syms\n\
3955   --dyn-syms             Display the dynamic symbol table\n\
3956   -n --notes             Display the core notes (if present)\n\
3957   -r --relocs            Display the relocations (if present)\n\
3958   -u --unwind            Display the unwind info (if present)\n\
3959   -d --dynamic           Display the dynamic section (if present)\n\
3960   -V --version-info      Display the version sections (if present)\n\
3961   -A --arch-specific     Display architecture specific information (if any)\n\
3962   -c --archive-index     Display the symbol/file index in an archive\n\
3963   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3964   -x --hex-dump=<number|name>\n\
3965                          Dump the contents of section <number|name> as bytes\n\
3966   -p --string-dump=<number|name>\n\
3967                          Dump the contents of section <number|name> as strings\n\
3968   -R --relocated-dump=<number|name>\n\
3969                          Dump the contents of section <number|name> as relocated bytes\n\
3970   -w[lLiaprmfFsoRt] or\n\
3971   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3972                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3973                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3974                =addr,=cu_index]\n\
3975                          Display the contents of DWARF2 debug sections\n"));
3976   fprintf (stream, _("\
3977   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3978   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3979                          or deeper\n"));
3980 #ifdef SUPPORT_DISASSEMBLY
3981   fprintf (stream, _("\
3982   -i --instruction-dump=<number|name>\n\
3983                          Disassemble the contents of section <number|name>\n"));
3984 #endif
3985   fprintf (stream, _("\
3986   -I --histogram         Display histogram of bucket list lengths\n\
3987   -W --wide              Allow output width to exceed 80 characters\n\
3988   @<file>                Read options from <file>\n\
3989   -H --help              Display this information\n\
3990   -v --version           Display the version number of readelf\n"));
3991
3992   if (REPORT_BUGS_TO[0] && stream == stdout)
3993     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3994
3995   exit (stream == stdout ? 0 : 1);
3996 }
3997
3998 /* Record the fact that the user wants the contents of section number
3999    SECTION to be displayed using the method(s) encoded as flags bits
4000    in TYPE.  Note, TYPE can be zero if we are creating the array for
4001    the first time.  */
4002
4003 static void
4004 request_dump_bynumber (unsigned int section, dump_type type)
4005 {
4006   if (section >= num_dump_sects)
4007     {
4008       dump_type * new_dump_sects;
4009
4010       new_dump_sects = (dump_type *) calloc (section + 1,
4011                                              sizeof (* dump_sects));
4012
4013       if (new_dump_sects == NULL)
4014         error (_("Out of memory allocating dump request table.\n"));
4015       else
4016         {
4017           /* Copy current flag settings.  */
4018           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4019
4020           free (dump_sects);
4021
4022           dump_sects = new_dump_sects;
4023           num_dump_sects = section + 1;
4024         }
4025     }
4026
4027   if (dump_sects)
4028     dump_sects[section] |= type;
4029
4030   return;
4031 }
4032
4033 /* Request a dump by section name.  */
4034
4035 static void
4036 request_dump_byname (const char * section, dump_type type)
4037 {
4038   struct dump_list_entry * new_request;
4039
4040   new_request = (struct dump_list_entry *)
4041       malloc (sizeof (struct dump_list_entry));
4042   if (!new_request)
4043     error (_("Out of memory allocating dump request table.\n"));
4044
4045   new_request->name = strdup (section);
4046   if (!new_request->name)
4047     error (_("Out of memory allocating dump request table.\n"));
4048
4049   new_request->type = type;
4050
4051   new_request->next = dump_sects_byname;
4052   dump_sects_byname = new_request;
4053 }
4054
4055 static inline void
4056 request_dump (dump_type type)
4057 {
4058   int section;
4059   char * cp;
4060
4061   do_dump++;
4062   section = strtoul (optarg, & cp, 0);
4063
4064   if (! *cp && section >= 0)
4065     request_dump_bynumber (section, type);
4066   else
4067     request_dump_byname (optarg, type);
4068 }
4069
4070
4071 static void
4072 parse_args (int argc, char ** argv)
4073 {
4074   int c;
4075
4076   if (argc < 2)
4077     usage (stderr);
4078
4079   while ((c = getopt_long
4080           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4081     {
4082       switch (c)
4083         {
4084         case 0:
4085           /* Long options.  */
4086           break;
4087         case 'H':
4088           usage (stdout);
4089           break;
4090
4091         case 'a':
4092           do_syms++;
4093           do_reloc++;
4094           do_unwind++;
4095           do_dynamic++;
4096           do_header++;
4097           do_sections++;
4098           do_section_groups++;
4099           do_segments++;
4100           do_version++;
4101           do_histogram++;
4102           do_arch++;
4103           do_notes++;
4104           break;
4105         case 'g':
4106           do_section_groups++;
4107           break;
4108         case 't':
4109         case 'N':
4110           do_sections++;
4111           do_section_details++;
4112           break;
4113         case 'e':
4114           do_header++;
4115           do_sections++;
4116           do_segments++;
4117           break;
4118         case 'A':
4119           do_arch++;
4120           break;
4121         case 'D':
4122           do_using_dynamic++;
4123           break;
4124         case 'r':
4125           do_reloc++;
4126           break;
4127         case 'u':
4128           do_unwind++;
4129           break;
4130         case 'h':
4131           do_header++;
4132           break;
4133         case 'l':
4134           do_segments++;
4135           break;
4136         case 's':
4137           do_syms++;
4138           break;
4139         case 'S':
4140           do_sections++;
4141           break;
4142         case 'd':
4143           do_dynamic++;
4144           break;
4145         case 'I':
4146           do_histogram++;
4147           break;
4148         case 'n':
4149           do_notes++;
4150           break;
4151         case 'c':
4152           do_archive_index++;
4153           break;
4154         case 'x':
4155           request_dump (HEX_DUMP);
4156           break;
4157         case 'p':
4158           request_dump (STRING_DUMP);
4159           break;
4160         case 'R':
4161           request_dump (RELOC_DUMP);
4162           break;
4163         case 'w':
4164           do_dump++;
4165           if (optarg == 0)
4166             {
4167               do_debugging = 1;
4168               dwarf_select_sections_all ();
4169             }
4170           else
4171             {
4172               do_debugging = 0;
4173               dwarf_select_sections_by_letters (optarg);
4174             }
4175           break;
4176         case OPTION_DEBUG_DUMP:
4177           do_dump++;
4178           if (optarg == 0)
4179             do_debugging = 1;
4180           else
4181             {
4182               do_debugging = 0;
4183               dwarf_select_sections_by_names (optarg);
4184             }
4185           break;
4186         case OPTION_DWARF_DEPTH:
4187           {
4188             char *cp;
4189
4190             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4191           }
4192           break;
4193         case OPTION_DWARF_START:
4194           {
4195             char *cp;
4196
4197             dwarf_start_die = strtoul (optarg, & cp, 0);
4198           }
4199           break;
4200         case OPTION_DWARF_CHECK:
4201           dwarf_check = 1;
4202           break;
4203         case OPTION_DYN_SYMS:
4204           do_dyn_syms++;
4205           break;
4206 #ifdef SUPPORT_DISASSEMBLY
4207         case 'i':
4208           request_dump (DISASS_DUMP);
4209           break;
4210 #endif
4211         case 'v':
4212           print_version (program_name);
4213           break;
4214         case 'V':
4215           do_version++;
4216           break;
4217         case 'W':
4218           do_wide++;
4219           break;
4220         default:
4221           /* xgettext:c-format */
4222           error (_("Invalid option '-%c'\n"), c);
4223           /* Drop through.  */
4224         case '?':
4225           usage (stderr);
4226         }
4227     }
4228
4229   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4230       && !do_segments && !do_header && !do_dump && !do_version
4231       && !do_histogram && !do_debugging && !do_arch && !do_notes
4232       && !do_section_groups && !do_archive_index
4233       && !do_dyn_syms)
4234     usage (stderr);
4235 }
4236
4237 static const char *
4238 get_elf_class (unsigned int elf_class)
4239 {
4240   static char buff[32];
4241
4242   switch (elf_class)
4243     {
4244     case ELFCLASSNONE: return _("none");
4245     case ELFCLASS32:   return "ELF32";
4246     case ELFCLASS64:   return "ELF64";
4247     default:
4248       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4249       return buff;
4250     }
4251 }
4252
4253 static const char *
4254 get_data_encoding (unsigned int encoding)
4255 {
4256   static char buff[32];
4257
4258   switch (encoding)
4259     {
4260     case ELFDATANONE: return _("none");
4261     case ELFDATA2LSB: return _("2's complement, little endian");
4262     case ELFDATA2MSB: return _("2's complement, big endian");
4263     default:
4264       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4265       return buff;
4266     }
4267 }
4268
4269 /* Decode the data held in 'elf_header'.  */
4270
4271 static int
4272 process_file_header (void)
4273 {
4274   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4275       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4276       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4277       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4278     {
4279       error
4280         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4281       return 0;
4282     }
4283
4284   init_dwarf_regnames (elf_header.e_machine);
4285
4286   if (do_header)
4287     {
4288       int i;
4289
4290       printf (_("ELF Header:\n"));
4291       printf (_("  Magic:   "));
4292       for (i = 0; i < EI_NIDENT; i++)
4293         printf ("%2.2x ", elf_header.e_ident[i]);
4294       printf ("\n");
4295       printf (_("  Class:                             %s\n"),
4296               get_elf_class (elf_header.e_ident[EI_CLASS]));
4297       printf (_("  Data:                              %s\n"),
4298               get_data_encoding (elf_header.e_ident[EI_DATA]));
4299       printf (_("  Version:                           %d %s\n"),
4300               elf_header.e_ident[EI_VERSION],
4301               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4302                ? "(current)"
4303                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4304                   ? _("<unknown: %lx>")
4305                   : "")));
4306       printf (_("  OS/ABI:                            %s\n"),
4307               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4308       printf (_("  ABI Version:                       %d\n"),
4309               elf_header.e_ident[EI_ABIVERSION]);
4310       printf (_("  Type:                              %s\n"),
4311               get_file_type (elf_header.e_type));
4312       printf (_("  Machine:                           %s\n"),
4313               get_machine_name (elf_header.e_machine));
4314       printf (_("  Version:                           0x%lx\n"),
4315               (unsigned long) elf_header.e_version);
4316
4317       printf (_("  Entry point address:               "));
4318       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4319       printf (_("\n  Start of program headers:          "));
4320       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4321       printf (_(" (bytes into file)\n  Start of section headers:          "));
4322       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4323       printf (_(" (bytes into file)\n"));
4324
4325       printf (_("  Flags:                             0x%lx%s\n"),
4326               (unsigned long) elf_header.e_flags,
4327               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4328       printf (_("  Size of this header:               %ld (bytes)\n"),
4329               (long) elf_header.e_ehsize);
4330       printf (_("  Size of program headers:           %ld (bytes)\n"),
4331               (long) elf_header.e_phentsize);
4332       printf (_("  Number of program headers:         %ld"),
4333               (long) elf_header.e_phnum);
4334       if (section_headers != NULL
4335           && elf_header.e_phnum == PN_XNUM
4336           && section_headers[0].sh_info != 0)
4337         printf (" (%ld)", (long) section_headers[0].sh_info);
4338       putc ('\n', stdout);
4339       printf (_("  Size of section headers:           %ld (bytes)\n"),
4340               (long) elf_header.e_shentsize);
4341       printf (_("  Number of section headers:         %ld"),
4342               (long) elf_header.e_shnum);
4343       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4344         printf (" (%ld)", (long) section_headers[0].sh_size);
4345       putc ('\n', stdout);
4346       printf (_("  Section header string table index: %ld"),
4347               (long) elf_header.e_shstrndx);
4348       if (section_headers != NULL
4349           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4350         printf (" (%u)", section_headers[0].sh_link);
4351       else if (elf_header.e_shstrndx != SHN_UNDEF
4352                && elf_header.e_shstrndx >= elf_header.e_shnum)
4353         printf (_(" <corrupt: out of range>"));
4354       putc ('\n', stdout);
4355     }
4356
4357   if (section_headers != NULL)
4358     {
4359       if (elf_header.e_phnum == PN_XNUM
4360           && section_headers[0].sh_info != 0)
4361         elf_header.e_phnum = section_headers[0].sh_info;
4362       if (elf_header.e_shnum == SHN_UNDEF)
4363         elf_header.e_shnum = section_headers[0].sh_size;
4364       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4365         elf_header.e_shstrndx = section_headers[0].sh_link;
4366       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4367         elf_header.e_shstrndx = SHN_UNDEF;
4368       free (section_headers);
4369       section_headers = NULL;
4370     }
4371
4372   return 1;
4373 }
4374
4375 static bfd_boolean
4376 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4377 {
4378   Elf32_External_Phdr * phdrs;
4379   Elf32_External_Phdr * external;
4380   Elf_Internal_Phdr *   internal;
4381   unsigned int i;
4382   unsigned int size = elf_header.e_phentsize;
4383   unsigned int num  = elf_header.e_phnum;
4384
4385   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4386   if (size == 0 || num == 0)
4387     return FALSE;
4388   if (size < sizeof * phdrs)
4389     {
4390       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4391       return FALSE;
4392     }
4393   if (size > sizeof * phdrs)
4394     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4395
4396   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4397                                             size, num, _("program headers"));
4398   if (phdrs == NULL)
4399     return FALSE;
4400
4401   for (i = 0, internal = pheaders, external = phdrs;
4402        i < elf_header.e_phnum;
4403        i++, internal++, external++)
4404     {
4405       internal->p_type   = BYTE_GET (external->p_type);
4406       internal->p_offset = BYTE_GET (external->p_offset);
4407       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4408       internal->p_paddr  = BYTE_GET (external->p_paddr);
4409       internal->p_filesz = BYTE_GET (external->p_filesz);
4410       internal->p_memsz  = BYTE_GET (external->p_memsz);
4411       internal->p_flags  = BYTE_GET (external->p_flags);
4412       internal->p_align  = BYTE_GET (external->p_align);
4413     }
4414
4415   free (phdrs);
4416   return TRUE;
4417 }
4418
4419 static bfd_boolean
4420 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4421 {
4422   Elf64_External_Phdr * phdrs;
4423   Elf64_External_Phdr * external;
4424   Elf_Internal_Phdr *   internal;
4425   unsigned int i;
4426   unsigned int size = elf_header.e_phentsize;
4427   unsigned int num  = elf_header.e_phnum;
4428
4429   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4430   if (size == 0 || num == 0)
4431     return FALSE;
4432   if (size < sizeof * phdrs)
4433     {
4434       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4435       return FALSE;
4436     }
4437   if (size > sizeof * phdrs)
4438     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4439
4440   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4441                                             size, num, _("program headers"));
4442   if (!phdrs)
4443     return FALSE;
4444
4445   for (i = 0, internal = pheaders, external = phdrs;
4446        i < elf_header.e_phnum;
4447        i++, internal++, external++)
4448     {
4449       internal->p_type   = BYTE_GET (external->p_type);
4450       internal->p_flags  = BYTE_GET (external->p_flags);
4451       internal->p_offset = BYTE_GET (external->p_offset);
4452       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4453       internal->p_paddr  = BYTE_GET (external->p_paddr);
4454       internal->p_filesz = BYTE_GET (external->p_filesz);
4455       internal->p_memsz  = BYTE_GET (external->p_memsz);
4456       internal->p_align  = BYTE_GET (external->p_align);
4457     }
4458
4459   free (phdrs);
4460   return TRUE;
4461 }
4462
4463 /* Returns 1 if the program headers were read into `program_headers'.  */
4464
4465 static int
4466 get_program_headers (FILE * file)
4467 {
4468   Elf_Internal_Phdr * phdrs;
4469
4470   /* Check cache of prior read.  */
4471   if (program_headers != NULL)
4472     return 1;
4473
4474   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4475                                          sizeof (Elf_Internal_Phdr));
4476
4477   if (phdrs == NULL)
4478     {
4479       error (_("Out of memory reading %u program headers\n"),
4480              elf_header.e_phnum);
4481       return 0;
4482     }
4483
4484   if (is_32bit_elf
4485       ? get_32bit_program_headers (file, phdrs)
4486       : get_64bit_program_headers (file, phdrs))
4487     {
4488       program_headers = phdrs;
4489       return 1;
4490     }
4491
4492   free (phdrs);
4493   return 0;
4494 }
4495
4496 /* Returns 1 if the program headers were loaded.  */
4497
4498 static int
4499 process_program_headers (FILE * file)
4500 {
4501   Elf_Internal_Phdr * segment;
4502   unsigned int i;
4503
4504   if (elf_header.e_phnum == 0)
4505     {
4506       /* PR binutils/12467.  */
4507       if (elf_header.e_phoff != 0)
4508         warn (_("possibly corrupt ELF header - it has a non-zero program"
4509                 " header offset, but no program headers\n"));
4510       else if (do_segments)
4511         printf (_("\nThere are no program headers in this file.\n"));
4512       return 0;
4513     }
4514
4515   if (do_segments && !do_header)
4516     {
4517       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4518       printf (_("Entry point "));
4519       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4520       printf (_("\nThere are %d program headers, starting at offset "),
4521               elf_header.e_phnum);
4522       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4523       printf ("\n");
4524     }
4525
4526   if (! get_program_headers (file))
4527       return 0;
4528
4529   if (do_segments)
4530     {
4531       if (elf_header.e_phnum > 1)
4532         printf (_("\nProgram Headers:\n"));
4533       else
4534         printf (_("\nProgram Headers:\n"));
4535
4536       if (is_32bit_elf)
4537         printf
4538           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4539       else if (do_wide)
4540         printf
4541           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4542       else
4543         {
4544           printf
4545             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4546           printf
4547             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4548         }
4549     }
4550
4551   dynamic_addr = 0;
4552   dynamic_size = 0;
4553
4554   for (i = 0, segment = program_headers;
4555        i < elf_header.e_phnum;
4556        i++, segment++)
4557     {
4558       if (do_segments)
4559         {
4560           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4561
4562           if (is_32bit_elf)
4563             {
4564               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4565               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4566               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4567               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4568               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4569               printf ("%c%c%c ",
4570                       (segment->p_flags & PF_R ? 'R' : ' '),
4571                       (segment->p_flags & PF_W ? 'W' : ' '),
4572                       (segment->p_flags & PF_X ? 'E' : ' '));
4573               printf ("%#lx", (unsigned long) segment->p_align);
4574             }
4575           else if (do_wide)
4576             {
4577               if ((unsigned long) segment->p_offset == segment->p_offset)
4578                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4579               else
4580                 {
4581                   print_vma (segment->p_offset, FULL_HEX);
4582                   putchar (' ');
4583                 }
4584
4585               print_vma (segment->p_vaddr, FULL_HEX);
4586               putchar (' ');
4587               print_vma (segment->p_paddr, FULL_HEX);
4588               putchar (' ');
4589
4590               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4591                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4592               else
4593                 {
4594                   print_vma (segment->p_filesz, FULL_HEX);
4595                   putchar (' ');
4596                 }
4597
4598               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4599                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4600               else
4601                 {
4602                   print_vma (segment->p_memsz, FULL_HEX);
4603                 }
4604
4605               printf (" %c%c%c ",
4606                       (segment->p_flags & PF_R ? 'R' : ' '),
4607                       (segment->p_flags & PF_W ? 'W' : ' '),
4608                       (segment->p_flags & PF_X ? 'E' : ' '));
4609
4610               if ((unsigned long) segment->p_align == segment->p_align)
4611                 printf ("%#lx", (unsigned long) segment->p_align);
4612               else
4613                 {
4614                   print_vma (segment->p_align, PREFIX_HEX);
4615                 }
4616             }
4617           else
4618             {
4619               print_vma (segment->p_offset, FULL_HEX);
4620               putchar (' ');
4621               print_vma (segment->p_vaddr, FULL_HEX);
4622               putchar (' ');
4623               print_vma (segment->p_paddr, FULL_HEX);
4624               printf ("\n                 ");
4625               print_vma (segment->p_filesz, FULL_HEX);
4626               putchar (' ');
4627               print_vma (segment->p_memsz, FULL_HEX);
4628               printf ("  %c%c%c    ",
4629                       (segment->p_flags & PF_R ? 'R' : ' '),
4630                       (segment->p_flags & PF_W ? 'W' : ' '),
4631                       (segment->p_flags & PF_X ? 'E' : ' '));
4632               print_vma (segment->p_align, HEX);
4633             }
4634         }
4635
4636       if (do_segments)
4637         putc ('\n', stdout);
4638
4639       switch (segment->p_type)
4640         {
4641         case PT_DYNAMIC:
4642           if (dynamic_addr)
4643             error (_("more than one dynamic segment\n"));
4644
4645           /* By default, assume that the .dynamic section is the first
4646              section in the DYNAMIC segment.  */
4647           dynamic_addr = segment->p_offset;
4648           dynamic_size = segment->p_filesz;
4649           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4650           if (dynamic_addr + dynamic_size >= current_file_size)
4651             {
4652               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4653               dynamic_addr = dynamic_size = 0;
4654             }
4655
4656           /* Try to locate the .dynamic section. If there is
4657              a section header table, we can easily locate it.  */
4658           if (section_headers != NULL)
4659             {
4660               Elf_Internal_Shdr * sec;
4661
4662               sec = find_section (".dynamic");
4663               if (sec == NULL || sec->sh_size == 0)
4664                 {
4665                   /* A corresponding .dynamic section is expected, but on
4666                      IA-64/OpenVMS it is OK for it to be missing.  */
4667                   if (!is_ia64_vms ())
4668                     error (_("no .dynamic section in the dynamic segment\n"));
4669                   break;
4670                 }
4671
4672               if (sec->sh_type == SHT_NOBITS)
4673                 {
4674                   dynamic_size = 0;
4675                   break;
4676                 }
4677
4678               dynamic_addr = sec->sh_offset;
4679               dynamic_size = sec->sh_size;
4680
4681               if (dynamic_addr < segment->p_offset
4682                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4683                 warn (_("the .dynamic section is not contained"
4684                         " within the dynamic segment\n"));
4685               else if (dynamic_addr > segment->p_offset)
4686                 warn (_("the .dynamic section is not the first section"
4687                         " in the dynamic segment.\n"));
4688             }
4689           break;
4690
4691         case PT_INTERP:
4692           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4693                      SEEK_SET))
4694             error (_("Unable to find program interpreter name\n"));
4695           else
4696             {
4697               char fmt [32];
4698               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4699
4700               if (ret >= (int) sizeof (fmt) || ret < 0)
4701                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4702
4703               program_interpreter[0] = 0;
4704               if (fscanf (file, fmt, program_interpreter) <= 0)
4705                 error (_("Unable to read program interpreter name\n"));
4706
4707               if (do_segments)
4708                 printf (_("      [Requesting program interpreter: %s]\n"),
4709                     program_interpreter);
4710             }
4711           break;
4712         }
4713     }
4714
4715   if (do_segments && section_headers != NULL && string_table != NULL)
4716     {
4717       printf (_("\n Section to Segment mapping:\n"));
4718       printf (_("  Segment Sections...\n"));
4719
4720       for (i = 0; i < elf_header.e_phnum; i++)
4721         {
4722           unsigned int j;
4723           Elf_Internal_Shdr * section;
4724
4725           segment = program_headers + i;
4726           section = section_headers + 1;
4727
4728           printf ("   %2.2d     ", i);
4729
4730           for (j = 1; j < elf_header.e_shnum; j++, section++)
4731             {
4732               if (!ELF_TBSS_SPECIAL (section, segment)
4733                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4734                 printf ("%s ", printable_section_name (section));
4735             }
4736
4737           putc ('\n',stdout);
4738         }
4739     }
4740
4741   return 1;
4742 }
4743
4744
4745 /* Find the file offset corresponding to VMA by using the program headers.  */
4746
4747 static long
4748 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4749 {
4750   Elf_Internal_Phdr * seg;
4751
4752   if (! get_program_headers (file))
4753     {
4754       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4755       return (long) vma;
4756     }
4757
4758   for (seg = program_headers;
4759        seg < program_headers + elf_header.e_phnum;
4760        ++seg)
4761     {
4762       if (seg->p_type != PT_LOAD)
4763         continue;
4764
4765       if (vma >= (seg->p_vaddr & -seg->p_align)
4766           && vma + size <= seg->p_vaddr + seg->p_filesz)
4767         return vma - seg->p_vaddr + seg->p_offset;
4768     }
4769
4770   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4771         (unsigned long) vma);
4772   return (long) vma;
4773 }
4774
4775
4776 /* Allocate memory and load the sections headers into the global pointer
4777    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4778    generate any error messages if the load fails.  */
4779
4780 static bfd_boolean
4781 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4782 {
4783   Elf32_External_Shdr * shdrs;
4784   Elf_Internal_Shdr *   internal;
4785   unsigned int i;
4786   unsigned int size = elf_header.e_shentsize;
4787   unsigned int num = probe ? 1 : elf_header.e_shnum;
4788
4789   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4790   if (size == 0 || num == 0)
4791     return FALSE;
4792   if (size < sizeof * shdrs)
4793     {
4794       if (! probe)
4795         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4796       return FALSE;
4797     }
4798   if (!probe && size > sizeof * shdrs)
4799     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4800
4801   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4802                                             size, num,
4803                                             probe ? NULL : _("section headers"));
4804   if (shdrs == NULL)
4805     return FALSE;
4806
4807   if (section_headers != NULL)
4808     free (section_headers);
4809   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4810                                                    sizeof (Elf_Internal_Shdr));
4811   if (section_headers == NULL)
4812     {
4813       if (!probe)
4814         error (_("Out of memory reading %u section headers\n"), num);
4815       return FALSE;
4816     }
4817
4818   for (i = 0, internal = section_headers;
4819        i < num;
4820        i++, internal++)
4821     {
4822       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4823       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4824       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4825       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4826       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4827       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4828       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4829       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4830       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4831       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4832     }
4833
4834   free (shdrs);
4835   return TRUE;
4836 }
4837
4838 static bfd_boolean
4839 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4840 {
4841   Elf64_External_Shdr * shdrs;
4842   Elf_Internal_Shdr *   internal;
4843   unsigned int i;
4844   unsigned int size = elf_header.e_shentsize;
4845   unsigned int num = probe ? 1 : elf_header.e_shnum;
4846
4847   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4848   if (size == 0 || num == 0)
4849     return FALSE;
4850   if (size < sizeof * shdrs)
4851     {
4852       if (! probe)
4853         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4854       return FALSE;
4855     }
4856   if (! probe && size > sizeof * shdrs)
4857     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4858
4859   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4860                                             size, num,
4861                                             probe ? NULL : _("section headers"));
4862   if (shdrs == NULL)
4863     return FALSE;
4864
4865   if (section_headers != NULL)
4866     free (section_headers);
4867   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4868                                                    sizeof (Elf_Internal_Shdr));
4869   if (section_headers == NULL)
4870     {
4871       if (! probe)
4872         error (_("Out of memory reading %u section headers\n"), num);
4873       return FALSE;
4874     }
4875
4876   for (i = 0, internal = section_headers;
4877        i < num;
4878        i++, internal++)
4879     {
4880       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4881       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4882       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4883       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4884       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4885       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4886       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4887       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4888       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4889       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4890     }
4891
4892   free (shdrs);
4893   return TRUE;
4894 }
4895
4896 static Elf_Internal_Sym *
4897 get_32bit_elf_symbols (FILE * file,
4898                        Elf_Internal_Shdr * section,
4899                        unsigned long * num_syms_return)
4900 {
4901   unsigned long number = 0;
4902   Elf32_External_Sym * esyms = NULL;
4903   Elf_External_Sym_Shndx * shndx = NULL;
4904   Elf_Internal_Sym * isyms = NULL;
4905   Elf_Internal_Sym * psym;
4906   unsigned int j;
4907
4908   if (section->sh_size == 0)
4909     {
4910       if (num_syms_return != NULL)
4911         * num_syms_return = 0;
4912       return NULL;
4913     }
4914
4915   /* Run some sanity checks first.  */
4916   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4917     {
4918       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4919              printable_section_name (section), (unsigned long) section->sh_entsize);
4920       goto exit_point;
4921     }
4922
4923   if (section->sh_size > current_file_size)
4924     {
4925       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4926              printable_section_name (section), (unsigned long) section->sh_size);
4927       goto exit_point;
4928     }
4929
4930   number = section->sh_size / section->sh_entsize;
4931
4932   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4933     {
4934       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4935              (unsigned long) section->sh_size,
4936              printable_section_name (section),
4937              (unsigned long) section->sh_entsize);
4938       goto exit_point;
4939     }
4940
4941   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4942                                            section->sh_size, _("symbols"));
4943   if (esyms == NULL)
4944     goto exit_point;
4945
4946   shndx = NULL;
4947   if (symtab_shndx_hdr != NULL
4948       && (symtab_shndx_hdr->sh_link
4949           == (unsigned long) (section - section_headers)))
4950     {
4951       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4952                                                    symtab_shndx_hdr->sh_offset,
4953                                                    1, symtab_shndx_hdr->sh_size,
4954                                                    _("symbol table section indicies"));
4955       if (shndx == NULL)
4956         goto exit_point;
4957       /* PR17531: file: heap-buffer-overflow */
4958       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4959         {
4960           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4961                  printable_section_name (symtab_shndx_hdr),
4962                  (unsigned long) symtab_shndx_hdr->sh_size,
4963                  (unsigned long) section->sh_size);
4964           goto exit_point;
4965         }
4966     }
4967
4968   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4969
4970   if (isyms == NULL)
4971     {
4972       error (_("Out of memory reading %lu symbols\n"),
4973              (unsigned long) number);
4974       goto exit_point;
4975     }
4976
4977   for (j = 0, psym = isyms; j < number; j++, psym++)
4978     {
4979       psym->st_name  = BYTE_GET (esyms[j].st_name);
4980       psym->st_value = BYTE_GET (esyms[j].st_value);
4981       psym->st_size  = BYTE_GET (esyms[j].st_size);
4982       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4983       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4984         psym->st_shndx
4985           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4986       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4987         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4988       psym->st_info  = BYTE_GET (esyms[j].st_info);
4989       psym->st_other = BYTE_GET (esyms[j].st_other);
4990     }
4991
4992  exit_point:
4993   if (shndx != NULL)
4994     free (shndx);
4995   if (esyms != NULL)
4996     free (esyms);
4997
4998   if (num_syms_return != NULL)
4999     * num_syms_return = isyms == NULL ? 0 : number;
5000
5001   return isyms;
5002 }
5003
5004 static Elf_Internal_Sym *
5005 get_64bit_elf_symbols (FILE * file,
5006                        Elf_Internal_Shdr * section,
5007                        unsigned long * num_syms_return)
5008 {
5009   unsigned long number = 0;
5010   Elf64_External_Sym * esyms = NULL;
5011   Elf_External_Sym_Shndx * shndx = NULL;
5012   Elf_Internal_Sym * isyms = NULL;
5013   Elf_Internal_Sym * psym;
5014   unsigned int j;
5015
5016   if (section->sh_size == 0)
5017     {
5018       if (num_syms_return != NULL)
5019         * num_syms_return = 0;
5020       return NULL;
5021     }
5022
5023   /* Run some sanity checks first.  */
5024   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5025     {
5026       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5027              printable_section_name (section),
5028              (unsigned long) section->sh_entsize);
5029       goto exit_point;
5030     }
5031
5032   if (section->sh_size > current_file_size)
5033     {
5034       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5035              printable_section_name (section),
5036              (unsigned long) section->sh_size);
5037       goto exit_point;
5038     }
5039
5040   number = section->sh_size / section->sh_entsize;
5041
5042   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5043     {
5044       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5045              (unsigned long) section->sh_size,
5046              printable_section_name (section),
5047              (unsigned long) section->sh_entsize);
5048       goto exit_point;
5049     }
5050
5051   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5052                                            section->sh_size, _("symbols"));
5053   if (!esyms)
5054     goto exit_point;
5055
5056   if (symtab_shndx_hdr != NULL
5057       && (symtab_shndx_hdr->sh_link
5058           == (unsigned long) (section - section_headers)))
5059     {
5060       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5061                                                    symtab_shndx_hdr->sh_offset,
5062                                                    1, symtab_shndx_hdr->sh_size,
5063                                                    _("symbol table section indicies"));
5064       if (shndx == NULL)
5065         goto exit_point;
5066       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5067         {
5068           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5069                  printable_section_name (symtab_shndx_hdr),
5070                  (unsigned long) symtab_shndx_hdr->sh_size,
5071                  (unsigned long) section->sh_size);
5072           goto exit_point;
5073         }
5074     }
5075
5076   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5077
5078   if (isyms == NULL)
5079     {
5080       error (_("Out of memory reading %lu symbols\n"),
5081              (unsigned long) number);
5082       goto exit_point;
5083     }
5084
5085   for (j = 0, psym = isyms; j < number; j++, psym++)
5086     {
5087       psym->st_name  = BYTE_GET (esyms[j].st_name);
5088       psym->st_info  = BYTE_GET (esyms[j].st_info);
5089       psym->st_other = BYTE_GET (esyms[j].st_other);
5090       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5091
5092       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5093         psym->st_shndx
5094           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5095       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5096         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5097
5098       psym->st_value = BYTE_GET (esyms[j].st_value);
5099       psym->st_size  = BYTE_GET (esyms[j].st_size);
5100     }
5101
5102  exit_point:
5103   if (shndx != NULL)
5104     free (shndx);
5105   if (esyms != NULL)
5106     free (esyms);
5107
5108   if (num_syms_return != NULL)
5109     * num_syms_return = isyms == NULL ? 0 : number;
5110
5111   return isyms;
5112 }
5113
5114 static const char *
5115 get_elf_section_flags (bfd_vma sh_flags)
5116 {
5117   static char buff[1024];
5118   char * p = buff;
5119   int field_size = is_32bit_elf ? 8 : 16;
5120   int sindex;
5121   int size = sizeof (buff) - (field_size + 4 + 1);
5122   bfd_vma os_flags = 0;
5123   bfd_vma proc_flags = 0;
5124   bfd_vma unknown_flags = 0;
5125   static const struct
5126     {
5127       const char * str;
5128       int len;
5129     }
5130   flags [] =
5131     {
5132       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5133       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5134       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5135       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5136       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5137       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5138       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5139       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5140       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5141       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5142       /* IA-64 specific.  */
5143       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5144       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5145       /* IA-64 OpenVMS specific.  */
5146       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5147       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5148       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5149       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5150       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5151       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5152       /* Generic.  */
5153       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5154       /* SPARC specific.  */
5155       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5156     };
5157
5158   if (do_section_details)
5159     {
5160       sprintf (buff, "[%*.*lx]: ",
5161                field_size, field_size, (unsigned long) sh_flags);
5162       p += field_size + 4;
5163     }
5164
5165   while (sh_flags)
5166     {
5167       bfd_vma flag;
5168
5169       flag = sh_flags & - sh_flags;
5170       sh_flags &= ~ flag;
5171
5172       if (do_section_details)
5173         {
5174           switch (flag)
5175             {
5176             case SHF_WRITE:             sindex = 0; break;
5177             case SHF_ALLOC:             sindex = 1; break;
5178             case SHF_EXECINSTR:         sindex = 2; break;
5179             case SHF_MERGE:             sindex = 3; break;
5180             case SHF_STRINGS:           sindex = 4; break;
5181             case SHF_INFO_LINK:         sindex = 5; break;
5182             case SHF_LINK_ORDER:        sindex = 6; break;
5183             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5184             case SHF_GROUP:             sindex = 8; break;
5185             case SHF_TLS:               sindex = 9; break;
5186             case SHF_EXCLUDE:           sindex = 18; break;
5187
5188             default:
5189               sindex = -1;
5190               switch (elf_header.e_machine)
5191                 {
5192                 case EM_IA_64:
5193                   if (flag == SHF_IA_64_SHORT)
5194                     sindex = 10;
5195                   else if (flag == SHF_IA_64_NORECOV)
5196                     sindex = 11;
5197 #ifdef BFD64
5198                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5199                     switch (flag)
5200                       {
5201                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5202                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5203                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5204                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5205                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5206                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5207                       default:                        break;
5208                       }
5209 #endif
5210                   break;
5211
5212                 case EM_386:
5213                 case EM_486:
5214                 case EM_X86_64:
5215                 case EM_L1OM:
5216                 case EM_K1OM:
5217                 case EM_OLD_SPARCV9:
5218                 case EM_SPARC32PLUS:
5219                 case EM_SPARCV9:
5220                 case EM_SPARC:
5221                   if (flag == SHF_ORDERED)
5222                     sindex = 19;
5223                   break;
5224                 default:
5225                   break;
5226                 }
5227             }
5228
5229           if (sindex != -1)
5230             {
5231               if (p != buff + field_size + 4)
5232                 {
5233                   if (size < (10 + 2))
5234                     {
5235                       warn (_("Internal error: not enough buffer room for section flag info"));
5236                       return _("<unknown>");
5237                     }
5238                   size -= 2;
5239                   *p++ = ',';
5240                   *p++ = ' ';
5241                 }
5242
5243               size -= flags [sindex].len;
5244               p = stpcpy (p, flags [sindex].str);
5245             }
5246           else if (flag & SHF_MASKOS)
5247             os_flags |= flag;
5248           else if (flag & SHF_MASKPROC)
5249             proc_flags |= flag;
5250           else
5251             unknown_flags |= flag;
5252         }
5253       else
5254         {
5255           switch (flag)
5256             {
5257             case SHF_WRITE:             *p = 'W'; break;
5258             case SHF_ALLOC:             *p = 'A'; break;
5259             case SHF_EXECINSTR:         *p = 'X'; break;
5260             case SHF_MERGE:             *p = 'M'; break;
5261             case SHF_STRINGS:           *p = 'S'; break;
5262             case SHF_INFO_LINK:         *p = 'I'; break;
5263             case SHF_LINK_ORDER:        *p = 'L'; break;
5264             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5265             case SHF_GROUP:             *p = 'G'; break;
5266             case SHF_TLS:               *p = 'T'; break;
5267             case SHF_EXCLUDE:           *p = 'E'; break;
5268
5269             default:
5270               if ((elf_header.e_machine == EM_X86_64
5271                    || elf_header.e_machine == EM_L1OM
5272                    || elf_header.e_machine == EM_K1OM)
5273                   && flag == SHF_X86_64_LARGE)
5274                 *p = 'l';
5275               else if (flag & SHF_MASKOS)
5276                 {
5277                   *p = 'o';
5278                   sh_flags &= ~ SHF_MASKOS;
5279                 }
5280               else if (flag & SHF_MASKPROC)
5281                 {
5282                   *p = 'p';
5283                   sh_flags &= ~ SHF_MASKPROC;
5284                 }
5285               else
5286                 *p = 'x';
5287               break;
5288             }
5289           p++;
5290         }
5291     }
5292
5293   if (do_section_details)
5294     {
5295       if (os_flags)
5296         {
5297           size -= 5 + field_size;
5298           if (p != buff + field_size + 4)
5299             {
5300               if (size < (2 + 1))
5301                 {
5302                   warn (_("Internal error: not enough buffer room for section flag info"));
5303                   return _("<unknown>");
5304                 }
5305               size -= 2;
5306               *p++ = ',';
5307               *p++ = ' ';
5308             }
5309           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5310                    (unsigned long) os_flags);
5311           p += 5 + field_size;
5312         }
5313       if (proc_flags)
5314         {
5315           size -= 7 + field_size;
5316           if (p != buff + field_size + 4)
5317             {
5318               if (size < (2 + 1))
5319                 {
5320                   warn (_("Internal error: not enough buffer room for section flag info"));
5321                   return _("<unknown>");
5322                 }
5323               size -= 2;
5324               *p++ = ',';
5325               *p++ = ' ';
5326             }
5327           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5328                    (unsigned long) proc_flags);
5329           p += 7 + field_size;
5330         }
5331       if (unknown_flags)
5332         {
5333           size -= 10 + field_size;
5334           if (p != buff + field_size + 4)
5335             {
5336               if (size < (2 + 1))
5337                 {
5338                   warn (_("Internal error: not enough buffer room for section flag info"));
5339                   return _("<unknown>");
5340                 }
5341               size -= 2;
5342               *p++ = ',';
5343               *p++ = ' ';
5344             }
5345           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5346                    (unsigned long) unknown_flags);
5347           p += 10 + field_size;
5348         }
5349     }
5350
5351   *p = '\0';
5352   return buff;
5353 }
5354
5355 static int
5356 process_section_headers (FILE * file)
5357 {
5358   Elf_Internal_Shdr * section;
5359   unsigned int i;
5360
5361   section_headers = NULL;
5362
5363   if (elf_header.e_shnum == 0)
5364     {
5365       /* PR binutils/12467.  */
5366       if (elf_header.e_shoff != 0)
5367         warn (_("possibly corrupt ELF file header - it has a non-zero"
5368                 " section header offset, but no section headers\n"));
5369       else if (do_sections)
5370         printf (_("\nThere are no sections in this file.\n"));
5371
5372       return 1;
5373     }
5374
5375   if (do_sections && !do_header)
5376     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5377             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5378
5379   if (is_32bit_elf)
5380     {
5381       if (! get_32bit_section_headers (file, FALSE))
5382         return 0;
5383     }
5384   else if (! get_64bit_section_headers (file, FALSE))
5385     return 0;
5386
5387   /* Read in the string table, so that we have names to display.  */
5388   if (elf_header.e_shstrndx != SHN_UNDEF
5389        && elf_header.e_shstrndx < elf_header.e_shnum)
5390     {
5391       section = section_headers + elf_header.e_shstrndx;
5392
5393       if (section->sh_size != 0)
5394         {
5395           string_table = (char *) get_data (NULL, file, section->sh_offset,
5396                                             1, section->sh_size,
5397                                             _("string table"));
5398
5399           string_table_length = string_table != NULL ? section->sh_size : 0;
5400         }
5401     }
5402
5403   /* Scan the sections for the dynamic symbol table
5404      and dynamic string table and debug sections.  */
5405   dynamic_symbols = NULL;
5406   dynamic_strings = NULL;
5407   dynamic_syminfo = NULL;
5408   symtab_shndx_hdr = NULL;
5409
5410   eh_addr_size = is_32bit_elf ? 4 : 8;
5411   switch (elf_header.e_machine)
5412     {
5413     case EM_MIPS:
5414     case EM_MIPS_RS3_LE:
5415       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5416          FDE addresses.  However, the ABI also has a semi-official ILP32
5417          variant for which the normal FDE address size rules apply.
5418
5419          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5420          section, where XX is the size of longs in bits.  Unfortunately,
5421          earlier compilers provided no way of distinguishing ILP32 objects
5422          from LP64 objects, so if there's any doubt, we should assume that
5423          the official LP64 form is being used.  */
5424       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5425           && find_section (".gcc_compiled_long32") == NULL)
5426         eh_addr_size = 8;
5427       break;
5428
5429     case EM_H8_300:
5430     case EM_H8_300H:
5431       switch (elf_header.e_flags & EF_H8_MACH)
5432         {
5433         case E_H8_MACH_H8300:
5434         case E_H8_MACH_H8300HN:
5435         case E_H8_MACH_H8300SN:
5436         case E_H8_MACH_H8300SXN:
5437           eh_addr_size = 2;
5438           break;
5439         case E_H8_MACH_H8300H:
5440         case E_H8_MACH_H8300S:
5441         case E_H8_MACH_H8300SX:
5442           eh_addr_size = 4;
5443           break;
5444         }
5445       break;
5446
5447     case EM_M32C_OLD:
5448     case EM_M32C:
5449       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5450         {
5451         case EF_M32C_CPU_M16C:
5452           eh_addr_size = 2;
5453           break;
5454         }
5455       break;
5456     }
5457
5458 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5459   do                                                                    \
5460     {                                                                   \
5461       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5462       if (section->sh_entsize != expected_entsize)                      \
5463         {                                                               \
5464           char buf[40];                                                 \
5465           sprintf_vma (buf, section->sh_entsize);                       \
5466           /* Note: coded this way so that there is a single string for  \
5467              translation.  */ \
5468           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5469           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5470                    (unsigned) expected_entsize);                        \
5471           section->sh_entsize = expected_entsize;                       \
5472         }                                                               \
5473     }                                                                   \
5474   while (0)
5475
5476 #define CHECK_ENTSIZE(section, i, type)                                 \
5477   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5478                         sizeof (Elf64_External_##type))
5479
5480   for (i = 0, section = section_headers;
5481        i < elf_header.e_shnum;
5482        i++, section++)
5483     {
5484       char * name = SECTION_NAME (section);
5485
5486       if (section->sh_type == SHT_DYNSYM)
5487         {
5488           if (dynamic_symbols != NULL)
5489             {
5490               error (_("File contains multiple dynamic symbol tables\n"));
5491               continue;
5492             }
5493
5494           CHECK_ENTSIZE (section, i, Sym);
5495           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5496         }
5497       else if (section->sh_type == SHT_STRTAB
5498                && streq (name, ".dynstr"))
5499         {
5500           if (dynamic_strings != NULL)
5501             {
5502               error (_("File contains multiple dynamic string tables\n"));
5503               continue;
5504             }
5505
5506           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5507                                                1, section->sh_size,
5508                                                _("dynamic strings"));
5509           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5510         }
5511       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5512         {
5513           if (symtab_shndx_hdr != NULL)
5514             {
5515               error (_("File contains multiple symtab shndx tables\n"));
5516               continue;
5517             }
5518           symtab_shndx_hdr = section;
5519         }
5520       else if (section->sh_type == SHT_SYMTAB)
5521         CHECK_ENTSIZE (section, i, Sym);
5522       else if (section->sh_type == SHT_GROUP)
5523         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5524       else if (section->sh_type == SHT_REL)
5525         CHECK_ENTSIZE (section, i, Rel);
5526       else if (section->sh_type == SHT_RELA)
5527         CHECK_ENTSIZE (section, i, Rela);
5528       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5529                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5530                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5531                 || do_debug_str || do_debug_loc || do_debug_ranges
5532                 || do_debug_addr || do_debug_cu_index)
5533                && (const_strneq (name, ".debug_")
5534                    || const_strneq (name, ".zdebug_")))
5535         {
5536           if (name[1] == 'z')
5537             name += sizeof (".zdebug_") - 1;
5538           else
5539             name += sizeof (".debug_") - 1;
5540
5541           if (do_debugging
5542               || (do_debug_info     && const_strneq (name, "info"))
5543               || (do_debug_info     && const_strneq (name, "types"))
5544               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5545               || (do_debug_lines    && strcmp (name, "line") == 0)
5546               || (do_debug_lines    && const_strneq (name, "line."))
5547               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5548               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5549               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5550               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5551               || (do_debug_aranges  && const_strneq (name, "aranges"))
5552               || (do_debug_ranges   && const_strneq (name, "ranges"))
5553               || (do_debug_frames   && const_strneq (name, "frame"))
5554               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5555               || (do_debug_macinfo  && const_strneq (name, "macro"))
5556               || (do_debug_str      && const_strneq (name, "str"))
5557               || (do_debug_loc      && const_strneq (name, "loc"))
5558               || (do_debug_addr     && const_strneq (name, "addr"))
5559               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5560               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5561               )
5562             request_dump_bynumber (i, DEBUG_DUMP);
5563         }
5564       /* Linkonce section to be combined with .debug_info at link time.  */
5565       else if ((do_debugging || do_debug_info)
5566                && const_strneq (name, ".gnu.linkonce.wi."))
5567         request_dump_bynumber (i, DEBUG_DUMP);
5568       else if (do_debug_frames && streq (name, ".eh_frame"))
5569         request_dump_bynumber (i, DEBUG_DUMP);
5570       else if (do_gdb_index && streq (name, ".gdb_index"))
5571         request_dump_bynumber (i, DEBUG_DUMP);
5572       /* Trace sections for Itanium VMS.  */
5573       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5574                 || do_trace_aranges)
5575                && const_strneq (name, ".trace_"))
5576         {
5577           name += sizeof (".trace_") - 1;
5578
5579           if (do_debugging
5580               || (do_trace_info     && streq (name, "info"))
5581               || (do_trace_abbrevs  && streq (name, "abbrev"))
5582               || (do_trace_aranges  && streq (name, "aranges"))
5583               )
5584             request_dump_bynumber (i, DEBUG_DUMP);
5585         }
5586     }
5587
5588   if (! do_sections)
5589     return 1;
5590
5591   if (elf_header.e_shnum > 1)
5592     printf (_("\nSection Headers:\n"));
5593   else
5594     printf (_("\nSection Header:\n"));
5595
5596   if (is_32bit_elf)
5597     {
5598       if (do_section_details)
5599         {
5600           printf (_("  [Nr] Name\n"));
5601           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5602         }
5603       else
5604         printf
5605           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5606     }
5607   else if (do_wide)
5608     {
5609       if (do_section_details)
5610         {
5611           printf (_("  [Nr] Name\n"));
5612           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5613         }
5614       else
5615         printf
5616           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5617     }
5618   else
5619     {
5620       if (do_section_details)
5621         {
5622           printf (_("  [Nr] Name\n"));
5623           printf (_("       Type              Address          Offset            Link\n"));
5624           printf (_("       Size              EntSize          Info              Align\n"));
5625         }
5626       else
5627         {
5628           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5629           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5630         }
5631     }
5632
5633   if (do_section_details)
5634     printf (_("       Flags\n"));
5635
5636   for (i = 0, section = section_headers;
5637        i < elf_header.e_shnum;
5638        i++, section++)
5639     {
5640       printf ("  [%2u] ", i);
5641       if (do_section_details)
5642         printf ("%s\n      ", printable_section_name (section));
5643       else
5644         print_symbol (-17, SECTION_NAME (section));
5645
5646       printf (do_wide ? " %-15s " : " %-15.15s ",
5647               get_section_type_name (section->sh_type));
5648
5649       if (is_32bit_elf)
5650         {
5651           const char * link_too_big = NULL;
5652
5653           print_vma (section->sh_addr, LONG_HEX);
5654
5655           printf ( " %6.6lx %6.6lx %2.2lx",
5656                    (unsigned long) section->sh_offset,
5657                    (unsigned long) section->sh_size,
5658                    (unsigned long) section->sh_entsize);
5659
5660           if (do_section_details)
5661             fputs ("  ", stdout);
5662           else
5663             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5664
5665           if (section->sh_link >= elf_header.e_shnum)
5666             {
5667               link_too_big = "";
5668               /* The sh_link value is out of range.  Normally this indicates
5669                  an error but it can have special values in Solaris binaries.  */
5670               switch (elf_header.e_machine)
5671                 {
5672                 case EM_386:
5673                 case EM_486:
5674                 case EM_X86_64:
5675                 case EM_L1OM:
5676                 case EM_K1OM:
5677                 case EM_OLD_SPARCV9:
5678                 case EM_SPARC32PLUS:
5679                 case EM_SPARCV9:
5680                 case EM_SPARC:
5681                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5682                     link_too_big = "BEFORE";
5683                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5684                     link_too_big = "AFTER";
5685                   break;
5686                 default:
5687                   break;
5688                 }
5689             }
5690
5691           if (do_section_details)
5692             {
5693               if (link_too_big != NULL && * link_too_big)
5694                 printf ("<%s> ", link_too_big);
5695               else
5696                 printf ("%2u ", section->sh_link);
5697               printf ("%3u %2lu\n", section->sh_info,
5698                       (unsigned long) section->sh_addralign);
5699             }
5700           else
5701             printf ("%2u %3u %2lu\n",
5702                     section->sh_link,
5703                     section->sh_info,
5704                     (unsigned long) section->sh_addralign);
5705
5706           if (link_too_big && ! * link_too_big)
5707             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5708                   i, section->sh_link);
5709         }
5710       else if (do_wide)
5711         {
5712           print_vma (section->sh_addr, LONG_HEX);
5713
5714           if ((long) section->sh_offset == section->sh_offset)
5715             printf (" %6.6lx", (unsigned long) section->sh_offset);
5716           else
5717             {
5718               putchar (' ');
5719               print_vma (section->sh_offset, LONG_HEX);
5720             }
5721
5722           if ((unsigned long) section->sh_size == section->sh_size)
5723             printf (" %6.6lx", (unsigned long) section->sh_size);
5724           else
5725             {
5726               putchar (' ');
5727               print_vma (section->sh_size, LONG_HEX);
5728             }
5729
5730           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5731             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5732           else
5733             {
5734               putchar (' ');
5735               print_vma (section->sh_entsize, LONG_HEX);
5736             }
5737
5738           if (do_section_details)
5739             fputs ("  ", stdout);
5740           else
5741             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5742
5743           printf ("%2u %3u ", section->sh_link, section->sh_info);
5744
5745           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5746             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5747           else
5748             {
5749               print_vma (section->sh_addralign, DEC);
5750               putchar ('\n');
5751             }
5752         }
5753       else if (do_section_details)
5754         {
5755           printf ("       %-15.15s  ",
5756                   get_section_type_name (section->sh_type));
5757           print_vma (section->sh_addr, LONG_HEX);
5758           if ((long) section->sh_offset == section->sh_offset)
5759             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5760           else
5761             {
5762               printf ("  ");
5763               print_vma (section->sh_offset, LONG_HEX);
5764             }
5765           printf ("  %u\n       ", section->sh_link);
5766           print_vma (section->sh_size, LONG_HEX);
5767           putchar (' ');
5768           print_vma (section->sh_entsize, LONG_HEX);
5769
5770           printf ("  %-16u  %lu\n",
5771                   section->sh_info,
5772                   (unsigned long) section->sh_addralign);
5773         }
5774       else
5775         {
5776           putchar (' ');
5777           print_vma (section->sh_addr, LONG_HEX);
5778           if ((long) section->sh_offset == section->sh_offset)
5779             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5780           else
5781             {
5782               printf ("  ");
5783               print_vma (section->sh_offset, LONG_HEX);
5784             }
5785           printf ("\n       ");
5786           print_vma (section->sh_size, LONG_HEX);
5787           printf ("  ");
5788           print_vma (section->sh_entsize, LONG_HEX);
5789
5790           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5791
5792           printf ("     %2u   %3u     %lu\n",
5793                   section->sh_link,
5794                   section->sh_info,
5795                   (unsigned long) section->sh_addralign);
5796         }
5797
5798       if (do_section_details)
5799         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5800     }
5801
5802   if (!do_section_details)
5803     {
5804       if (elf_header.e_machine == EM_X86_64
5805           || elf_header.e_machine == EM_L1OM
5806           || elf_header.e_machine == EM_K1OM)
5807         printf (_("Key to Flags:\n\
5808   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5809   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5810   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5811       else
5812         printf (_("Key to Flags:\n\
5813   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5814   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5815   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5816     }
5817
5818   return 1;
5819 }
5820
5821 static const char *
5822 get_group_flags (unsigned int flags)
5823 {
5824   static char buff[32];
5825   switch (flags)
5826     {
5827     case 0:
5828       return "";
5829
5830     case GRP_COMDAT:
5831       return "COMDAT ";
5832
5833    default:
5834       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5835       break;
5836     }
5837   return buff;
5838 }
5839
5840 static int
5841 process_section_groups (FILE * file)
5842 {
5843   Elf_Internal_Shdr * section;
5844   unsigned int i;
5845   struct group * group;
5846   Elf_Internal_Shdr * symtab_sec;
5847   Elf_Internal_Shdr * strtab_sec;
5848   Elf_Internal_Sym * symtab;
5849   unsigned long num_syms;
5850   char * strtab;
5851   size_t strtab_size;
5852
5853   /* Don't process section groups unless needed.  */
5854   if (!do_unwind && !do_section_groups)
5855     return 1;
5856
5857   if (elf_header.e_shnum == 0)
5858     {
5859       if (do_section_groups)
5860         printf (_("\nThere are no sections to group in this file.\n"));
5861
5862       return 1;
5863     }
5864
5865   if (section_headers == NULL)
5866     {
5867       error (_("Section headers are not available!\n"));
5868       /* PR 13622: This can happen with a corrupt ELF header.  */
5869       return 0;
5870     }
5871
5872   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5873                                                      sizeof (struct group *));
5874
5875   if (section_headers_groups == NULL)
5876     {
5877       error (_("Out of memory reading %u section group headers\n"),
5878              elf_header.e_shnum);
5879       return 0;
5880     }
5881
5882   /* Scan the sections for the group section.  */
5883   group_count = 0;
5884   for (i = 0, section = section_headers;
5885        i < elf_header.e_shnum;
5886        i++, section++)
5887     if (section->sh_type == SHT_GROUP)
5888       group_count++;
5889
5890   if (group_count == 0)
5891     {
5892       if (do_section_groups)
5893         printf (_("\nThere are no section groups in this file.\n"));
5894
5895       return 1;
5896     }
5897
5898   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5899
5900   if (section_groups == NULL)
5901     {
5902       error (_("Out of memory reading %lu groups\n"),
5903              (unsigned long) group_count);
5904       return 0;
5905     }
5906
5907   symtab_sec = NULL;
5908   strtab_sec = NULL;
5909   symtab = NULL;
5910   num_syms = 0;
5911   strtab = NULL;
5912   strtab_size = 0;
5913   for (i = 0, section = section_headers, group = section_groups;
5914        i < elf_header.e_shnum;
5915        i++, section++)
5916     {
5917       if (section->sh_type == SHT_GROUP)
5918         {
5919           const char * name = printable_section_name (section);
5920           const char * group_name;
5921           unsigned char * start;
5922           unsigned char * indices;
5923           unsigned int entry, j, size;
5924           Elf_Internal_Shdr * sec;
5925           Elf_Internal_Sym * sym;
5926
5927           /* Get the symbol table.  */
5928           if (section->sh_link >= elf_header.e_shnum
5929               || ((sec = section_headers + section->sh_link)->sh_type
5930                   != SHT_SYMTAB))
5931             {
5932               error (_("Bad sh_link in group section `%s'\n"), name);
5933               continue;
5934             }
5935
5936           if (symtab_sec != sec)
5937             {
5938               symtab_sec = sec;
5939               if (symtab)
5940                 free (symtab);
5941               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5942             }
5943
5944           if (symtab == NULL)
5945             {
5946               error (_("Corrupt header in group section `%s'\n"), name);
5947               continue;
5948             }
5949
5950           if (section->sh_info >= num_syms)
5951             {
5952               error (_("Bad sh_info in group section `%s'\n"), name);
5953               continue;
5954             }
5955
5956           sym = symtab + section->sh_info;
5957
5958           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5959             {
5960               if (sym->st_shndx == 0
5961                   || sym->st_shndx >= elf_header.e_shnum)
5962                 {
5963                   error (_("Bad sh_info in group section `%s'\n"), name);
5964                   continue;
5965                 }
5966
5967               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5968               strtab_sec = NULL;
5969               if (strtab)
5970                 free (strtab);
5971               strtab = NULL;
5972               strtab_size = 0;
5973             }
5974           else
5975             {
5976               /* Get the string table.  */
5977               if (symtab_sec->sh_link >= elf_header.e_shnum)
5978                 {
5979                   strtab_sec = NULL;
5980                   if (strtab)
5981                     free (strtab);
5982                   strtab = NULL;
5983                   strtab_size = 0;
5984                 }
5985               else if (strtab_sec
5986                        != (sec = section_headers + symtab_sec->sh_link))
5987                 {
5988                   strtab_sec = sec;
5989                   if (strtab)
5990                     free (strtab);
5991
5992                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5993                                               1, strtab_sec->sh_size,
5994                                               _("string table"));
5995                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5996                 }
5997               group_name = sym->st_name < strtab_size
5998                 ? strtab + sym->st_name : _("<corrupt>");
5999             }
6000
6001           /* PR 17531: file: loop.  */
6002           if (section->sh_entsize > section->sh_size)
6003             {
6004               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6005                      printable_section_name (section),
6006                      (unsigned long) section->sh_entsize,
6007                      (unsigned long) section->sh_size);
6008               break;
6009             }
6010
6011           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6012                                               1, section->sh_size,
6013                                               _("section data"));
6014           if (start == NULL)
6015             continue;
6016
6017           indices = start;
6018           size = (section->sh_size / section->sh_entsize) - 1;
6019           entry = byte_get (indices, 4);
6020           indices += 4;
6021
6022           if (do_section_groups)
6023             {
6024               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6025                       get_group_flags (entry), i, name, group_name, size);
6026
6027               printf (_("   [Index]    Name\n"));
6028             }
6029
6030           group->group_index = i;
6031
6032           for (j = 0; j < size; j++)
6033             {
6034               struct group_list * g;
6035
6036               entry = byte_get (indices, 4);
6037               indices += 4;
6038
6039               if (entry >= elf_header.e_shnum)
6040                 {
6041                   static unsigned num_group_errors = 0;
6042
6043                   if (num_group_errors ++ < 10)
6044                     {
6045                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6046                              entry, i, elf_header.e_shnum - 1);
6047                       if (num_group_errors == 10)
6048                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6049                     }
6050                   continue;
6051                 }
6052
6053               if (section_headers_groups [entry] != NULL)
6054                 {
6055                   if (entry)
6056                     {
6057                       static unsigned num_errs = 0;
6058
6059                       if (num_errs ++ < 10)
6060                         {
6061                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6062                                  entry, i,
6063                                  section_headers_groups [entry]->group_index);
6064                           if (num_errs == 10)
6065                             warn (_("Further error messages about already contained group sections suppressed\n"));
6066                         }
6067                       continue;
6068                     }
6069                   else
6070                     {
6071                       /* Intel C/C++ compiler may put section 0 in a
6072                          section group. We just warn it the first time
6073                          and ignore it afterwards.  */
6074                       static int warned = 0;
6075                       if (!warned)
6076                         {
6077                           error (_("section 0 in group section [%5u]\n"),
6078                                  section_headers_groups [entry]->group_index);
6079                           warned++;
6080                         }
6081                     }
6082                 }
6083
6084               section_headers_groups [entry] = group;
6085
6086               if (do_section_groups)
6087                 {
6088                   sec = section_headers + entry;
6089                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6090                 }
6091
6092               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6093               g->section_index = entry;
6094               g->next = group->root;
6095               group->root = g;
6096             }
6097
6098           if (start)
6099             free (start);
6100
6101           group++;
6102         }
6103     }
6104
6105   if (symtab)
6106     free (symtab);
6107   if (strtab)
6108     free (strtab);
6109   return 1;
6110 }
6111
6112 /* Data used to display dynamic fixups.  */
6113
6114 struct ia64_vms_dynfixup
6115 {
6116   bfd_vma needed_ident;         /* Library ident number.  */
6117   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6118   bfd_vma fixup_needed;         /* Index of the library.  */
6119   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6120   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6121 };
6122
6123 /* Data used to display dynamic relocations.  */
6124
6125 struct ia64_vms_dynimgrela
6126 {
6127   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6128   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6129 };
6130
6131 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6132    library).  */
6133
6134 static void
6135 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6136                               const char *strtab, unsigned int strtab_sz)
6137 {
6138   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6139   long i;
6140   const char *lib_name;
6141
6142   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6143                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6144                    _("dynamic section image fixups"));
6145   if (!imfs)
6146     return;
6147
6148   if (fixup->needed < strtab_sz)
6149     lib_name = strtab + fixup->needed;
6150   else
6151     {
6152       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6153             (unsigned long) fixup->needed);
6154       lib_name = "???";
6155     }
6156   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6157           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6158   printf
6159     (_("Seg Offset           Type                             SymVec DataType\n"));
6160
6161   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6162     {
6163       unsigned int type;
6164       const char *rtype;
6165
6166       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6167       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6168       type = BYTE_GET (imfs [i].type);
6169       rtype = elf_ia64_reloc_type (type);
6170       if (rtype == NULL)
6171         printf (" 0x%08x                       ", type);
6172       else
6173         printf (" %-32s ", rtype);
6174       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6175       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6176     }
6177
6178   free (imfs);
6179 }
6180
6181 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6182
6183 static void
6184 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6185 {
6186   Elf64_External_VMS_IMAGE_RELA *imrs;
6187   long i;
6188
6189   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6190                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6191                    _("dynamic section image relocations"));
6192   if (!imrs)
6193     return;
6194
6195   printf (_("\nImage relocs\n"));
6196   printf
6197     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6198
6199   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6200     {
6201       unsigned int type;
6202       const char *rtype;
6203
6204       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6205       printf ("%08" BFD_VMA_FMT "x ",
6206               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6207       type = BYTE_GET (imrs [i].type);
6208       rtype = elf_ia64_reloc_type (type);
6209       if (rtype == NULL)
6210         printf ("0x%08x                      ", type);
6211       else
6212         printf ("%-31s ", rtype);
6213       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6214       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6215       printf ("%08" BFD_VMA_FMT "x\n",
6216               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6217     }
6218
6219   free (imrs);
6220 }
6221
6222 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6223
6224 static int
6225 process_ia64_vms_dynamic_relocs (FILE *file)
6226 {
6227   struct ia64_vms_dynfixup fixup;
6228   struct ia64_vms_dynimgrela imgrela;
6229   Elf_Internal_Dyn *entry;
6230   int res = 0;
6231   bfd_vma strtab_off = 0;
6232   bfd_vma strtab_sz = 0;
6233   char *strtab = NULL;
6234
6235   memset (&fixup, 0, sizeof (fixup));
6236   memset (&imgrela, 0, sizeof (imgrela));
6237
6238   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6239   for (entry = dynamic_section;
6240        entry < dynamic_section + dynamic_nent;
6241        entry++)
6242     {
6243       switch (entry->d_tag)
6244         {
6245         case DT_IA_64_VMS_STRTAB_OFFSET:
6246           strtab_off = entry->d_un.d_val;
6247           break;
6248         case DT_STRSZ:
6249           strtab_sz = entry->d_un.d_val;
6250           if (strtab == NULL)
6251             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6252                                1, strtab_sz, _("dynamic string section"));
6253           break;
6254
6255         case DT_IA_64_VMS_NEEDED_IDENT:
6256           fixup.needed_ident = entry->d_un.d_val;
6257           break;
6258         case DT_NEEDED:
6259           fixup.needed = entry->d_un.d_val;
6260           break;
6261         case DT_IA_64_VMS_FIXUP_NEEDED:
6262           fixup.fixup_needed = entry->d_un.d_val;
6263           break;
6264         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6265           fixup.fixup_rela_cnt = entry->d_un.d_val;
6266           break;
6267         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6268           fixup.fixup_rela_off = entry->d_un.d_val;
6269           res++;
6270           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6271           break;
6272
6273         case DT_IA_64_VMS_IMG_RELA_CNT:
6274           imgrela.img_rela_cnt = entry->d_un.d_val;
6275           break;
6276         case DT_IA_64_VMS_IMG_RELA_OFF:
6277           imgrela.img_rela_off = entry->d_un.d_val;
6278           res++;
6279           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6280           break;
6281
6282         default:
6283           break;
6284         }
6285     }
6286
6287   if (strtab != NULL)
6288     free (strtab);
6289
6290   return res;
6291 }
6292
6293 static struct
6294 {
6295   const char * name;
6296   int reloc;
6297   int size;
6298   int rela;
6299 } dynamic_relocations [] =
6300 {
6301     { "REL", DT_REL, DT_RELSZ, FALSE },
6302     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6303     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6304 };
6305
6306 /* Process the reloc section.  */
6307
6308 static int
6309 process_relocs (FILE * file)
6310 {
6311   unsigned long rel_size;
6312   unsigned long rel_offset;
6313
6314
6315   if (!do_reloc)
6316     return 1;
6317
6318   if (do_using_dynamic)
6319     {
6320       int is_rela;
6321       const char * name;
6322       int has_dynamic_reloc;
6323       unsigned int i;
6324
6325       has_dynamic_reloc = 0;
6326
6327       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6328         {
6329           is_rela = dynamic_relocations [i].rela;
6330           name = dynamic_relocations [i].name;
6331           rel_size = dynamic_info [dynamic_relocations [i].size];
6332           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6333
6334           has_dynamic_reloc |= rel_size;
6335
6336           if (is_rela == UNKNOWN)
6337             {
6338               if (dynamic_relocations [i].reloc == DT_JMPREL)
6339                 switch (dynamic_info[DT_PLTREL])
6340                   {
6341                   case DT_REL:
6342                     is_rela = FALSE;
6343                     break;
6344                   case DT_RELA:
6345                     is_rela = TRUE;
6346                     break;
6347                   }
6348             }
6349
6350           if (rel_size)
6351             {
6352               printf
6353                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6354                  name, rel_offset, rel_size);
6355
6356               dump_relocations (file,
6357                                 offset_from_vma (file, rel_offset, rel_size),
6358                                 rel_size,
6359                                 dynamic_symbols, num_dynamic_syms,
6360                                 dynamic_strings, dynamic_strings_length,
6361                                 is_rela, 1);
6362             }
6363         }
6364
6365       if (is_ia64_vms ())
6366         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6367
6368       if (! has_dynamic_reloc)
6369         printf (_("\nThere are no dynamic relocations in this file.\n"));
6370     }
6371   else
6372     {
6373       Elf_Internal_Shdr * section;
6374       unsigned long i;
6375       int found = 0;
6376
6377       for (i = 0, section = section_headers;
6378            i < elf_header.e_shnum;
6379            i++, section++)
6380         {
6381           if (   section->sh_type != SHT_RELA
6382               && section->sh_type != SHT_REL)
6383             continue;
6384
6385           rel_offset = section->sh_offset;
6386           rel_size   = section->sh_size;
6387
6388           if (rel_size)
6389             {
6390               Elf_Internal_Shdr * strsec;
6391               int is_rela;
6392
6393               printf (_("\nRelocation section "));
6394
6395               if (string_table == NULL)
6396                 printf ("%d", section->sh_name);
6397               else
6398                 printf ("'%s'", printable_section_name (section));
6399
6400               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6401                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6402
6403               is_rela = section->sh_type == SHT_RELA;
6404
6405               if (section->sh_link != 0
6406                   && section->sh_link < elf_header.e_shnum)
6407                 {
6408                   Elf_Internal_Shdr * symsec;
6409                   Elf_Internal_Sym *  symtab;
6410                   unsigned long nsyms;
6411                   unsigned long strtablen = 0;
6412                   char * strtab = NULL;
6413
6414                   symsec = section_headers + section->sh_link;
6415                   if (symsec->sh_type != SHT_SYMTAB
6416                       && symsec->sh_type != SHT_DYNSYM)
6417                     continue;
6418
6419                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6420
6421                   if (symtab == NULL)
6422                     continue;
6423
6424                   if (symsec->sh_link != 0
6425                       && symsec->sh_link < elf_header.e_shnum)
6426                     {
6427                       strsec = section_headers + symsec->sh_link;
6428
6429                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6430                                                   1, strsec->sh_size,
6431                                                   _("string table"));
6432                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6433                     }
6434
6435                   dump_relocations (file, rel_offset, rel_size,
6436                                     symtab, nsyms, strtab, strtablen,
6437                                     is_rela,
6438                                     symsec->sh_type == SHT_DYNSYM);
6439                   if (strtab)
6440                     free (strtab);
6441                   free (symtab);
6442                 }
6443               else
6444                 dump_relocations (file, rel_offset, rel_size,
6445                                   NULL, 0, NULL, 0, is_rela, 0);
6446
6447               found = 1;
6448             }
6449         }
6450
6451       if (! found)
6452         printf (_("\nThere are no relocations in this file.\n"));
6453     }
6454
6455   return 1;
6456 }
6457
6458 /* An absolute address consists of a section and an offset.  If the
6459    section is NULL, the offset itself is the address, otherwise, the
6460    address equals to LOAD_ADDRESS(section) + offset.  */
6461
6462 struct absaddr
6463 {
6464   unsigned short section;
6465   bfd_vma offset;
6466 };
6467
6468 #define ABSADDR(a) \
6469   ((a).section \
6470    ? section_headers [(a).section].sh_addr + (a).offset \
6471    : (a).offset)
6472
6473 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6474    name, if found, and the offset from the symbol to ADDR.  */
6475
6476 static void
6477 find_symbol_for_address (Elf_Internal_Sym * symtab,
6478                          unsigned long      nsyms,
6479                          const char *       strtab,
6480                          unsigned long      strtab_size,
6481                          struct absaddr     addr,
6482                          const char **      symname,
6483                          bfd_vma *          offset)
6484 {
6485   bfd_vma dist = 0x100000;
6486   Elf_Internal_Sym * sym;
6487   Elf_Internal_Sym * beg;
6488   Elf_Internal_Sym * end;
6489   Elf_Internal_Sym * best = NULL;
6490
6491   REMOVE_ARCH_BITS (addr.offset);
6492   beg = symtab;
6493   end = symtab + nsyms;
6494
6495   while (beg < end)
6496     {
6497       bfd_vma value;
6498
6499       sym = beg + (end - beg) / 2;
6500
6501       value = sym->st_value;
6502       REMOVE_ARCH_BITS (value);
6503
6504       if (sym->st_name != 0
6505           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6506           && addr.offset >= value
6507           && addr.offset - value < dist)
6508         {
6509           best = sym;
6510           dist = addr.offset - value;
6511           if (!dist)
6512             break;
6513         }
6514
6515       if (addr.offset < value)
6516         end = sym;
6517       else
6518         beg = sym + 1;
6519     }
6520
6521   if (best)
6522     {
6523       *symname = (best->st_name >= strtab_size
6524                   ? _("<corrupt>") : strtab + best->st_name);
6525       *offset = dist;
6526       return;
6527     }
6528
6529   *symname = NULL;
6530   *offset = addr.offset;
6531 }
6532
6533 static int
6534 symcmp (const void *p, const void *q)
6535 {
6536   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6537   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6538
6539   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6540 }
6541
6542 /* Process the unwind section.  */
6543
6544 #include "unwind-ia64.h"
6545
6546 struct ia64_unw_table_entry
6547 {
6548   struct absaddr start;
6549   struct absaddr end;
6550   struct absaddr info;
6551 };
6552
6553 struct ia64_unw_aux_info
6554 {
6555   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6556   unsigned long table_len;              /* Length of unwind table.  */
6557   unsigned char * info;                 /* Unwind info.  */
6558   unsigned long info_size;              /* Size of unwind info.  */
6559   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6560   bfd_vma seg_base;                     /* Starting address of segment.  */
6561   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6562   unsigned long nsyms;                  /* Number of symbols.  */
6563   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6564   unsigned long nfuns;                  /* Number of entries in funtab.  */
6565   char * strtab;                        /* The string table.  */
6566   unsigned long strtab_size;            /* Size of string table.  */
6567 };
6568
6569 static void
6570 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6571 {
6572   struct ia64_unw_table_entry * tp;
6573   unsigned long j, nfuns;
6574   int in_body;
6575
6576   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6577   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6578     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6579       aux->funtab[nfuns++] = aux->symtab[j];
6580   aux->nfuns = nfuns;
6581   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6582
6583   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6584     {
6585       bfd_vma stamp;
6586       bfd_vma offset;
6587       const unsigned char * dp;
6588       const unsigned char * head;
6589       const unsigned char * end;
6590       const char * procname;
6591
6592       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6593                                aux->strtab_size, tp->start, &procname, &offset);
6594
6595       fputs ("\n<", stdout);
6596
6597       if (procname)
6598         {
6599           fputs (procname, stdout);
6600
6601           if (offset)
6602             printf ("+%lx", (unsigned long) offset);
6603         }
6604
6605       fputs (">: [", stdout);
6606       print_vma (tp->start.offset, PREFIX_HEX);
6607       fputc ('-', stdout);
6608       print_vma (tp->end.offset, PREFIX_HEX);
6609       printf ("], info at +0x%lx\n",
6610               (unsigned long) (tp->info.offset - aux->seg_base));
6611
6612       /* PR 17531: file: 86232b32.  */
6613       if (aux->info == NULL)
6614         continue;
6615
6616       /* PR 17531: file: 0997b4d1.  */
6617       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6618         {
6619           warn (_("Invalid offset %lx in table entry %ld\n"),
6620                 (long) tp->info.offset, (long) (tp - aux->table));
6621           continue;
6622         }
6623
6624       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6625       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6626
6627       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6628               (unsigned) UNW_VER (stamp),
6629               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6630               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6631               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6632               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6633
6634       if (UNW_VER (stamp) != 1)
6635         {
6636           printf (_("\tUnknown version.\n"));
6637           continue;
6638         }
6639
6640       in_body = 0;
6641       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6642       /* PR 17531: file: 16ceda89.  */
6643       if (end > aux->info + aux->info_size)
6644         end = aux->info + aux->info_size;
6645       for (dp = head + 8; dp < end;)
6646         dp = unw_decode (dp, in_body, & in_body);
6647     }
6648
6649   free (aux->funtab);
6650 }
6651
6652 static bfd_boolean
6653 slurp_ia64_unwind_table (FILE * file,
6654                          struct ia64_unw_aux_info * aux,
6655                          Elf_Internal_Shdr * sec)
6656 {
6657   unsigned long size, nrelas, i;
6658   Elf_Internal_Phdr * seg;
6659   struct ia64_unw_table_entry * tep;
6660   Elf_Internal_Shdr * relsec;
6661   Elf_Internal_Rela * rela;
6662   Elf_Internal_Rela * rp;
6663   unsigned char * table;
6664   unsigned char * tp;
6665   Elf_Internal_Sym * sym;
6666   const char * relname;
6667
6668   aux->table_len = 0;
6669
6670   /* First, find the starting address of the segment that includes
6671      this section: */
6672
6673   if (elf_header.e_phnum)
6674     {
6675       if (! get_program_headers (file))
6676           return FALSE;
6677
6678       for (seg = program_headers;
6679            seg < program_headers + elf_header.e_phnum;
6680            ++seg)
6681         {
6682           if (seg->p_type != PT_LOAD)
6683             continue;
6684
6685           if (sec->sh_addr >= seg->p_vaddr
6686               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6687             {
6688               aux->seg_base = seg->p_vaddr;
6689               break;
6690             }
6691         }
6692     }
6693
6694   /* Second, build the unwind table from the contents of the unwind section:  */
6695   size = sec->sh_size;
6696   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6697                                       _("unwind table"));
6698   if (!table)
6699     return FALSE;
6700
6701   aux->table_len = size / (3 * eh_addr_size);
6702   aux->table = (struct ia64_unw_table_entry *)
6703     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6704   tep = aux->table;
6705
6706   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6707     {
6708       tep->start.section = SHN_UNDEF;
6709       tep->end.section   = SHN_UNDEF;
6710       tep->info.section  = SHN_UNDEF;
6711       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6712       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6713       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6714       tep->start.offset += aux->seg_base;
6715       tep->end.offset   += aux->seg_base;
6716       tep->info.offset  += aux->seg_base;
6717     }
6718   free (table);
6719
6720   /* Third, apply any relocations to the unwind table:  */
6721   for (relsec = section_headers;
6722        relsec < section_headers + elf_header.e_shnum;
6723        ++relsec)
6724     {
6725       if (relsec->sh_type != SHT_RELA
6726           || relsec->sh_info >= elf_header.e_shnum
6727           || section_headers + relsec->sh_info != sec)
6728         continue;
6729
6730       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6731                               & rela, & nrelas))
6732         {
6733           free (aux->table);
6734           aux->table = NULL;
6735           aux->table_len = 0;
6736           return FALSE;
6737         }
6738
6739       for (rp = rela; rp < rela + nrelas; ++rp)
6740         {
6741           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6742           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6743
6744           /* PR 17531: file: 9fa67536.  */
6745           if (relname == NULL)
6746             {
6747               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6748               continue;
6749             }
6750
6751           if (! const_strneq (relname, "R_IA64_SEGREL"))
6752             {
6753               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6754               continue;
6755             }
6756
6757           i = rp->r_offset / (3 * eh_addr_size);
6758
6759           /* PR 17531: file: 5bc8d9bf.  */
6760           if (i >= aux->table_len)
6761             {
6762               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6763               continue;
6764             }
6765
6766           switch (rp->r_offset / eh_addr_size % 3)
6767             {
6768             case 0:
6769               aux->table[i].start.section = sym->st_shndx;
6770               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6771               break;
6772             case 1:
6773               aux->table[i].end.section   = sym->st_shndx;
6774               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6775               break;
6776             case 2:
6777               aux->table[i].info.section  = sym->st_shndx;
6778               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6779               break;
6780             default:
6781               break;
6782             }
6783         }
6784
6785       free (rela);
6786     }
6787
6788   return TRUE;
6789 }
6790
6791 static void
6792 ia64_process_unwind (FILE * file)
6793 {
6794   Elf_Internal_Shdr * sec;
6795   Elf_Internal_Shdr * unwsec = NULL;
6796   Elf_Internal_Shdr * strsec;
6797   unsigned long i, unwcount = 0, unwstart = 0;
6798   struct ia64_unw_aux_info aux;
6799
6800   memset (& aux, 0, sizeof (aux));
6801
6802   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6803     {
6804       if (sec->sh_type == SHT_SYMTAB
6805           && sec->sh_link < elf_header.e_shnum)
6806         {
6807           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6808
6809           strsec = section_headers + sec->sh_link;
6810           if (aux.strtab != NULL)
6811             {
6812               error (_("Multiple auxillary string tables encountered\n"));
6813               free (aux.strtab);
6814             }
6815           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6816                                           1, strsec->sh_size,
6817                                           _("string table"));
6818           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6819         }
6820       else if (sec->sh_type == SHT_IA_64_UNWIND)
6821         unwcount++;
6822     }
6823
6824   if (!unwcount)
6825     printf (_("\nThere are no unwind sections in this file.\n"));
6826
6827   while (unwcount-- > 0)
6828     {
6829       char * suffix;
6830       size_t len, len2;
6831
6832       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6833            i < elf_header.e_shnum; ++i, ++sec)
6834         if (sec->sh_type == SHT_IA_64_UNWIND)
6835           {
6836             unwsec = sec;
6837             break;
6838           }
6839       /* We have already counted the number of SHT_IA64_UNWIND
6840          sections so the loop above should never fail.  */
6841       assert (unwsec != NULL);
6842
6843       unwstart = i + 1;
6844       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6845
6846       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6847         {
6848           /* We need to find which section group it is in.  */
6849           struct group_list * g;
6850
6851           if (section_headers_groups == NULL
6852               || section_headers_groups [i] == NULL)
6853             i = elf_header.e_shnum;
6854           else
6855             {
6856               g = section_headers_groups [i]->root;
6857
6858               for (; g != NULL; g = g->next)
6859                 {
6860                   sec = section_headers + g->section_index;
6861
6862                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6863                     break;
6864                 }
6865
6866               if (g == NULL)
6867                 i = elf_header.e_shnum;
6868             }
6869         }
6870       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6871         {
6872           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6873           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6874           suffix = SECTION_NAME (unwsec) + len;
6875           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6876                ++i, ++sec)
6877             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6878                 && streq (SECTION_NAME (sec) + len2, suffix))
6879               break;
6880         }
6881       else
6882         {
6883           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6884              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6885           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6886           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6887           suffix = "";
6888           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6889             suffix = SECTION_NAME (unwsec) + len;
6890           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6891                ++i, ++sec)
6892             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6893                 && streq (SECTION_NAME (sec) + len2, suffix))
6894               break;
6895         }
6896
6897       if (i == elf_header.e_shnum)
6898         {
6899           printf (_("\nCould not find unwind info section for "));
6900
6901           if (string_table == NULL)
6902             printf ("%d", unwsec->sh_name);
6903           else
6904             printf ("'%s'", printable_section_name (unwsec));
6905         }
6906       else
6907         {
6908           aux.info_addr = sec->sh_addr;
6909           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6910                                                  sec->sh_size,
6911                                                  _("unwind info"));
6912           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6913
6914           printf (_("\nUnwind section "));
6915
6916           if (string_table == NULL)
6917             printf ("%d", unwsec->sh_name);
6918           else
6919             printf ("'%s'", printable_section_name (unwsec));
6920
6921           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6922                   (unsigned long) unwsec->sh_offset,
6923                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6924
6925           if (slurp_ia64_unwind_table (file, & aux, unwsec)
6926               && aux.table_len > 0)
6927             dump_ia64_unwind (& aux);
6928
6929           if (aux.table)
6930             free ((char *) aux.table);
6931           if (aux.info)
6932             free ((char *) aux.info);
6933           aux.table = NULL;
6934           aux.info = NULL;
6935         }
6936     }
6937
6938   if (aux.symtab)
6939     free (aux.symtab);
6940   if (aux.strtab)
6941     free ((char *) aux.strtab);
6942 }
6943
6944 struct hppa_unw_table_entry
6945   {
6946     struct absaddr start;
6947     struct absaddr end;
6948     unsigned int Cannot_unwind:1;               /* 0 */
6949     unsigned int Millicode:1;                   /* 1 */
6950     unsigned int Millicode_save_sr0:1;          /* 2 */
6951     unsigned int Region_description:2;          /* 3..4 */
6952     unsigned int reserved1:1;                   /* 5 */
6953     unsigned int Entry_SR:1;                    /* 6 */
6954     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6955     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6956     unsigned int Args_stored:1;                 /* 16 */
6957     unsigned int Variable_Frame:1;              /* 17 */
6958     unsigned int Separate_Package_Body:1;       /* 18 */
6959     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6960     unsigned int Stack_Overflow_Check:1;        /* 20 */
6961     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
6962     unsigned int Ada_Region:1;                  /* 22 */
6963     unsigned int cxx_info:1;                    /* 23 */
6964     unsigned int cxx_try_catch:1;               /* 24 */
6965     unsigned int sched_entry_seq:1;             /* 25 */
6966     unsigned int reserved2:1;                   /* 26 */
6967     unsigned int Save_SP:1;                     /* 27 */
6968     unsigned int Save_RP:1;                     /* 28 */
6969     unsigned int Save_MRP_in_frame:1;           /* 29 */
6970     unsigned int extn_ptr_defined:1;            /* 30 */
6971     unsigned int Cleanup_defined:1;             /* 31 */
6972
6973     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
6974     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
6975     unsigned int Large_frame:1;                 /* 2 */
6976     unsigned int Pseudo_SP_Set:1;               /* 3 */
6977     unsigned int reserved4:1;                   /* 4 */
6978     unsigned int Total_frame_size:27;           /* 5..31 */
6979   };
6980
6981 struct hppa_unw_aux_info
6982 {
6983   struct hppa_unw_table_entry * table;  /* Unwind table.  */
6984   unsigned long table_len;              /* Length of unwind table.  */
6985   bfd_vma seg_base;                     /* Starting address of segment.  */
6986   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6987   unsigned long nsyms;                  /* Number of symbols.  */
6988   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6989   unsigned long nfuns;                  /* Number of entries in funtab.  */
6990   char * strtab;                        /* The string table.  */
6991   unsigned long strtab_size;            /* Size of string table.  */
6992 };
6993
6994 static void
6995 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6996 {
6997   struct hppa_unw_table_entry * tp;
6998   unsigned long j, nfuns;
6999
7000   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7001   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7002     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7003       aux->funtab[nfuns++] = aux->symtab[j];
7004   aux->nfuns = nfuns;
7005   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7006
7007   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7008     {
7009       bfd_vma offset;
7010       const char * procname;
7011
7012       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7013                                aux->strtab_size, tp->start, &procname,
7014                                &offset);
7015
7016       fputs ("\n<", stdout);
7017
7018       if (procname)
7019         {
7020           fputs (procname, stdout);
7021
7022           if (offset)
7023             printf ("+%lx", (unsigned long) offset);
7024         }
7025
7026       fputs (">: [", stdout);
7027       print_vma (tp->start.offset, PREFIX_HEX);
7028       fputc ('-', stdout);
7029       print_vma (tp->end.offset, PREFIX_HEX);
7030       printf ("]\n\t");
7031
7032 #define PF(_m) if (tp->_m) printf (#_m " ");
7033 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7034       PF(Cannot_unwind);
7035       PF(Millicode);
7036       PF(Millicode_save_sr0);
7037       /* PV(Region_description);  */
7038       PF(Entry_SR);
7039       PV(Entry_FR);
7040       PV(Entry_GR);
7041       PF(Args_stored);
7042       PF(Variable_Frame);
7043       PF(Separate_Package_Body);
7044       PF(Frame_Extension_Millicode);
7045       PF(Stack_Overflow_Check);
7046       PF(Two_Instruction_SP_Increment);
7047       PF(Ada_Region);
7048       PF(cxx_info);
7049       PF(cxx_try_catch);
7050       PF(sched_entry_seq);
7051       PF(Save_SP);
7052       PF(Save_RP);
7053       PF(Save_MRP_in_frame);
7054       PF(extn_ptr_defined);
7055       PF(Cleanup_defined);
7056       PF(MPE_XL_interrupt_marker);
7057       PF(HP_UX_interrupt_marker);
7058       PF(Large_frame);
7059       PF(Pseudo_SP_Set);
7060       PV(Total_frame_size);
7061 #undef PF
7062 #undef PV
7063     }
7064
7065   printf ("\n");
7066
7067   free (aux->funtab);
7068 }
7069
7070 static int
7071 slurp_hppa_unwind_table (FILE * file,
7072                          struct hppa_unw_aux_info * aux,
7073                          Elf_Internal_Shdr * sec)
7074 {
7075   unsigned long size, unw_ent_size, nentries, nrelas, i;
7076   Elf_Internal_Phdr * seg;
7077   struct hppa_unw_table_entry * tep;
7078   Elf_Internal_Shdr * relsec;
7079   Elf_Internal_Rela * rela;
7080   Elf_Internal_Rela * rp;
7081   unsigned char * table;
7082   unsigned char * tp;
7083   Elf_Internal_Sym * sym;
7084   const char * relname;
7085
7086   /* First, find the starting address of the segment that includes
7087      this section.  */
7088
7089   if (elf_header.e_phnum)
7090     {
7091       if (! get_program_headers (file))
7092         return 0;
7093
7094       for (seg = program_headers;
7095            seg < program_headers + elf_header.e_phnum;
7096            ++seg)
7097         {
7098           if (seg->p_type != PT_LOAD)
7099             continue;
7100
7101           if (sec->sh_addr >= seg->p_vaddr
7102               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7103             {
7104               aux->seg_base = seg->p_vaddr;
7105               break;
7106             }
7107         }
7108     }
7109
7110   /* Second, build the unwind table from the contents of the unwind
7111      section.  */
7112   size = sec->sh_size;
7113   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7114                                       _("unwind table"));
7115   if (!table)
7116     return 0;
7117
7118   unw_ent_size = 16;
7119   nentries = size / unw_ent_size;
7120   size = unw_ent_size * nentries;
7121
7122   tep = aux->table = (struct hppa_unw_table_entry *)
7123       xcmalloc (nentries, sizeof (aux->table[0]));
7124
7125   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7126     {
7127       unsigned int tmp1, tmp2;
7128
7129       tep->start.section = SHN_UNDEF;
7130       tep->end.section   = SHN_UNDEF;
7131
7132       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7133       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7134       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7135       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7136
7137       tep->start.offset += aux->seg_base;
7138       tep->end.offset   += aux->seg_base;
7139
7140       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7141       tep->Millicode = (tmp1 >> 30) & 0x1;
7142       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7143       tep->Region_description = (tmp1 >> 27) & 0x3;
7144       tep->reserved1 = (tmp1 >> 26) & 0x1;
7145       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7146       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7147       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7148       tep->Args_stored = (tmp1 >> 15) & 0x1;
7149       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7150       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7151       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7152       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7153       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7154       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7155       tep->cxx_info = (tmp1 >> 8) & 0x1;
7156       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7157       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7158       tep->reserved2 = (tmp1 >> 5) & 0x1;
7159       tep->Save_SP = (tmp1 >> 4) & 0x1;
7160       tep->Save_RP = (tmp1 >> 3) & 0x1;
7161       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7162       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7163       tep->Cleanup_defined = tmp1 & 0x1;
7164
7165       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7166       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7167       tep->Large_frame = (tmp2 >> 29) & 0x1;
7168       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7169       tep->reserved4 = (tmp2 >> 27) & 0x1;
7170       tep->Total_frame_size = tmp2 & 0x7ffffff;
7171     }
7172   free (table);
7173
7174   /* Third, apply any relocations to the unwind table.  */
7175   for (relsec = section_headers;
7176        relsec < section_headers + elf_header.e_shnum;
7177        ++relsec)
7178     {
7179       if (relsec->sh_type != SHT_RELA
7180           || relsec->sh_info >= elf_header.e_shnum
7181           || section_headers + relsec->sh_info != sec)
7182         continue;
7183
7184       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7185                               & rela, & nrelas))
7186         return 0;
7187
7188       for (rp = rela; rp < rela + nrelas; ++rp)
7189         {
7190           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7191           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7192
7193           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7194           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7195             {
7196               warn (_("Skipping unexpected relocation type %s\n"), relname);
7197               continue;
7198             }
7199
7200           i = rp->r_offset / unw_ent_size;
7201
7202           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7203             {
7204             case 0:
7205               aux->table[i].start.section = sym->st_shndx;
7206               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7207               break;
7208             case 1:
7209               aux->table[i].end.section   = sym->st_shndx;
7210               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7211               break;
7212             default:
7213               break;
7214             }
7215         }
7216
7217       free (rela);
7218     }
7219
7220   aux->table_len = nentries;
7221
7222   return 1;
7223 }
7224
7225 static void
7226 hppa_process_unwind (FILE * file)
7227 {
7228   struct hppa_unw_aux_info aux;
7229   Elf_Internal_Shdr * unwsec = NULL;
7230   Elf_Internal_Shdr * strsec;
7231   Elf_Internal_Shdr * sec;
7232   unsigned long i;
7233
7234   if (string_table == NULL)
7235     return;
7236
7237   memset (& aux, 0, sizeof (aux));
7238
7239   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7240     {
7241       if (sec->sh_type == SHT_SYMTAB
7242           && sec->sh_link < elf_header.e_shnum)
7243         {
7244           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7245
7246           strsec = section_headers + sec->sh_link;
7247           if (aux.strtab != NULL)
7248             {
7249               error (_("Multiple auxillary string tables encountered\n"));
7250               free (aux.strtab);
7251             }
7252           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7253                                           1, strsec->sh_size,
7254                                           _("string table"));
7255           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7256         }
7257       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7258         unwsec = sec;
7259     }
7260
7261   if (!unwsec)
7262     printf (_("\nThere are no unwind sections in this file.\n"));
7263
7264   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7265     {
7266       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7267         {
7268           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7269                   printable_section_name (sec),
7270                   (unsigned long) sec->sh_offset,
7271                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7272
7273           slurp_hppa_unwind_table (file, &aux, sec);
7274           if (aux.table_len > 0)
7275             dump_hppa_unwind (&aux);
7276
7277           if (aux.table)
7278             free ((char *) aux.table);
7279           aux.table = NULL;
7280         }
7281     }
7282
7283   if (aux.symtab)
7284     free (aux.symtab);
7285   if (aux.strtab)
7286     free ((char *) aux.strtab);
7287 }
7288
7289 struct arm_section
7290 {
7291   unsigned char *      data;            /* The unwind data.  */
7292   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7293   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7294   unsigned long        nrelas;          /* The number of relocations.  */
7295   unsigned int         rel_type;        /* REL or RELA ?  */
7296   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7297 };
7298
7299 struct arm_unw_aux_info
7300 {
7301   FILE *              file;             /* The file containing the unwind sections.  */
7302   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7303   unsigned long       nsyms;            /* Number of symbols.  */
7304   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7305   unsigned long       nfuns;            /* Number of these symbols.  */
7306   char *              strtab;           /* The file's string table.  */
7307   unsigned long       strtab_size;      /* Size of string table.  */
7308 };
7309
7310 static const char *
7311 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7312                         bfd_vma fn, struct absaddr addr)
7313 {
7314   const char *procname;
7315   bfd_vma sym_offset;
7316
7317   if (addr.section == SHN_UNDEF)
7318     addr.offset = fn;
7319
7320   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7321                            aux->strtab_size, addr, &procname,
7322                            &sym_offset);
7323
7324   print_vma (fn, PREFIX_HEX);
7325
7326   if (procname)
7327     {
7328       fputs (" <", stdout);
7329       fputs (procname, stdout);
7330
7331       if (sym_offset)
7332         printf ("+0x%lx", (unsigned long) sym_offset);
7333       fputc ('>', stdout);
7334     }
7335
7336   return procname;
7337 }
7338
7339 static void
7340 arm_free_section (struct arm_section *arm_sec)
7341 {
7342   if (arm_sec->data != NULL)
7343     free (arm_sec->data);
7344
7345   if (arm_sec->rela != NULL)
7346     free (arm_sec->rela);
7347 }
7348
7349 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7350       cached section and install SEC instead.
7351    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7352       and return its valued in * WORDP, relocating if necessary.
7353    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7354       relocation's offset in ADDR.
7355    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7356       into the string table of the symbol associated with the reloc.  If no
7357       reloc was applied store -1 there.
7358    5) Return TRUE upon success, FALSE otherwise.  */
7359
7360 static bfd_boolean
7361 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7362                          struct arm_section *       arm_sec,
7363                          Elf_Internal_Shdr *        sec,
7364                          bfd_vma                    word_offset,
7365                          unsigned int *             wordp,
7366                          struct absaddr *           addr,
7367                          bfd_vma *                  sym_name)
7368 {
7369   Elf_Internal_Rela *rp;
7370   Elf_Internal_Sym *sym;
7371   const char * relname;
7372   unsigned int word;
7373   bfd_boolean wrapped;
7374
7375   if (sec == NULL || arm_sec == NULL)
7376     return FALSE;
7377
7378   addr->section = SHN_UNDEF;
7379   addr->offset = 0;
7380
7381   if (sym_name != NULL)
7382     *sym_name = (bfd_vma) -1;
7383
7384   /* If necessary, update the section cache.  */
7385   if (sec != arm_sec->sec)
7386     {
7387       Elf_Internal_Shdr *relsec;
7388
7389       arm_free_section (arm_sec);
7390
7391       arm_sec->sec = sec;
7392       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7393                                 sec->sh_size, _("unwind data"));
7394       arm_sec->rela = NULL;
7395       arm_sec->nrelas = 0;
7396
7397       for (relsec = section_headers;
7398            relsec < section_headers + elf_header.e_shnum;
7399            ++relsec)
7400         {
7401           if (relsec->sh_info >= elf_header.e_shnum
7402               || section_headers + relsec->sh_info != sec
7403               /* PR 15745: Check the section type as well.  */
7404               || (relsec->sh_type != SHT_REL
7405                   && relsec->sh_type != SHT_RELA))
7406             continue;
7407
7408           arm_sec->rel_type = relsec->sh_type;
7409           if (relsec->sh_type == SHT_REL)
7410             {
7411               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7412                                      relsec->sh_size,
7413                                      & arm_sec->rela, & arm_sec->nrelas))
7414                 return FALSE;
7415             }
7416           else /* relsec->sh_type == SHT_RELA */
7417             {
7418               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7419                                       relsec->sh_size,
7420                                       & arm_sec->rela, & arm_sec->nrelas))
7421                 return FALSE;
7422             }
7423           break;
7424         }
7425
7426       arm_sec->next_rela = arm_sec->rela;
7427     }
7428
7429   /* If there is no unwind data we can do nothing.  */
7430   if (arm_sec->data == NULL)
7431     return FALSE;
7432
7433   /* If the offset is invalid then fail.  */
7434   if (word_offset > sec->sh_size - 4)
7435     return FALSE;
7436
7437   /* Get the word at the required offset.  */
7438   word = byte_get (arm_sec->data + word_offset, 4);
7439
7440   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7441   if (arm_sec->rela == NULL)
7442     {
7443       * wordp = word;
7444       return TRUE;
7445     }
7446
7447   /* Look through the relocs to find the one that applies to the provided offset.  */
7448   wrapped = FALSE;
7449   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7450     {
7451       bfd_vma prelval, offset;
7452
7453       if (rp->r_offset > word_offset && !wrapped)
7454         {
7455           rp = arm_sec->rela;
7456           wrapped = TRUE;
7457         }
7458       if (rp->r_offset > word_offset)
7459         break;
7460
7461       if (rp->r_offset & 3)
7462         {
7463           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7464                 (unsigned long) rp->r_offset);
7465           continue;
7466         }
7467
7468       if (rp->r_offset < word_offset)
7469         continue;
7470
7471       /* PR 17531: file: 027-161405-0.004  */
7472       if (aux->symtab == NULL)
7473         continue;
7474
7475       if (arm_sec->rel_type == SHT_REL)
7476         {
7477           offset = word & 0x7fffffff;
7478           if (offset & 0x40000000)
7479             offset |= ~ (bfd_vma) 0x7fffffff;
7480         }
7481       else if (arm_sec->rel_type == SHT_RELA)
7482         offset = rp->r_addend;
7483       else
7484         {
7485           error (_("Unknown section relocation type %d encountered\n"),
7486                  arm_sec->rel_type);
7487           break;
7488         }
7489
7490       /* PR 17531 file: 027-1241568-0.004.  */
7491       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7492         {
7493           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7494                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7495           break;
7496         }
7497
7498       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7499       offset += sym->st_value;
7500       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7501
7502       /* Check that we are processing the expected reloc type.  */
7503       if (elf_header.e_machine == EM_ARM)
7504         {
7505           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7506           if (relname == NULL)
7507             {
7508               warn (_("Skipping unknown ARM relocation type: %d\n"),
7509                     (int) ELF32_R_TYPE (rp->r_info));
7510               continue;
7511             }
7512
7513           if (streq (relname, "R_ARM_NONE"))
7514               continue;
7515
7516           if (! streq (relname, "R_ARM_PREL31"))
7517             {
7518               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7519               continue;
7520             }
7521         }
7522       else if (elf_header.e_machine == EM_TI_C6000)
7523         {
7524           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7525           if (relname == NULL)
7526             {
7527               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7528                     (int) ELF32_R_TYPE (rp->r_info));
7529               continue;
7530             }
7531
7532           if (streq (relname, "R_C6000_NONE"))
7533             continue;
7534
7535           if (! streq (relname, "R_C6000_PREL31"))
7536             {
7537               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7538               continue;
7539             }
7540
7541           prelval >>= 1;
7542         }
7543       else
7544         {
7545           /* This function currently only supports ARM and TI unwinders.  */
7546           warn (_("Only TI and ARM unwinders are currently supported\n"));
7547           break;
7548         }
7549
7550       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7551       addr->section = sym->st_shndx;
7552       addr->offset = offset;
7553
7554       if (sym_name)
7555         * sym_name = sym->st_name;
7556       break;
7557     }
7558
7559   *wordp = word;
7560   arm_sec->next_rela = rp;
7561
7562   return TRUE;
7563 }
7564
7565 static const char *tic6x_unwind_regnames[16] =
7566 {
7567   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7568   "A14", "A13", "A12", "A11", "A10",
7569   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7570 };
7571
7572 static void
7573 decode_tic6x_unwind_regmask (unsigned int mask)
7574 {
7575   int i;
7576
7577   for (i = 12; mask; mask >>= 1, i--)
7578     {
7579       if (mask & 1)
7580         {
7581           fputs (tic6x_unwind_regnames[i], stdout);
7582           if (mask > 1)
7583             fputs (", ", stdout);
7584         }
7585     }
7586 }
7587
7588 #define ADVANCE                                                 \
7589   if (remaining == 0 && more_words)                             \
7590     {                                                           \
7591       data_offset += 4;                                         \
7592       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7593                                      data_offset, & word, & addr, NULL))        \
7594         return;                                                 \
7595       remaining = 4;                                            \
7596       more_words--;                                             \
7597     }                                                           \
7598
7599 #define GET_OP(OP)                      \
7600   ADVANCE;                              \
7601   if (remaining)                        \
7602     {                                   \
7603       remaining--;                      \
7604       (OP) = word >> 24;                \
7605       word <<= 8;                       \
7606     }                                   \
7607   else                                  \
7608     {                                   \
7609       printf (_("[Truncated opcode]\n"));       \
7610       return;                           \
7611     }                                   \
7612   printf ("0x%02x ", OP)
7613
7614 static void
7615 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7616                             unsigned int               word,
7617                             unsigned int               remaining,
7618                             unsigned int               more_words,
7619                             bfd_vma                    data_offset,
7620                             Elf_Internal_Shdr *        data_sec,
7621                             struct arm_section *       data_arm_sec)
7622 {
7623   struct absaddr addr;
7624
7625   /* Decode the unwinding instructions.  */
7626   while (1)
7627     {
7628       unsigned int op, op2;
7629
7630       ADVANCE;
7631       if (remaining == 0)
7632         break;
7633       remaining--;
7634       op = word >> 24;
7635       word <<= 8;
7636
7637       printf ("  0x%02x ", op);
7638
7639       if ((op & 0xc0) == 0x00)
7640         {
7641           int offset = ((op & 0x3f) << 2) + 4;
7642
7643           printf ("     vsp = vsp + %d", offset);
7644         }
7645       else if ((op & 0xc0) == 0x40)
7646         {
7647           int offset = ((op & 0x3f) << 2) + 4;
7648
7649           printf ("     vsp = vsp - %d", offset);
7650         }
7651       else if ((op & 0xf0) == 0x80)
7652         {
7653           GET_OP (op2);
7654           if (op == 0x80 && op2 == 0)
7655             printf (_("Refuse to unwind"));
7656           else
7657             {
7658               unsigned int mask = ((op & 0x0f) << 8) | op2;
7659               int first = 1;
7660               int i;
7661
7662               printf ("pop {");
7663               for (i = 0; i < 12; i++)
7664                 if (mask & (1 << i))
7665                   {
7666                     if (first)
7667                       first = 0;
7668                     else
7669                       printf (", ");
7670                     printf ("r%d", 4 + i);
7671                   }
7672               printf ("}");
7673             }
7674         }
7675       else if ((op & 0xf0) == 0x90)
7676         {
7677           if (op == 0x9d || op == 0x9f)
7678             printf (_("     [Reserved]"));
7679           else
7680             printf ("     vsp = r%d", op & 0x0f);
7681         }
7682       else if ((op & 0xf0) == 0xa0)
7683         {
7684           int end = 4 + (op & 0x07);
7685           int first = 1;
7686           int i;
7687
7688           printf ("     pop {");
7689           for (i = 4; i <= end; i++)
7690             {
7691               if (first)
7692                 first = 0;
7693               else
7694                 printf (", ");
7695               printf ("r%d", i);
7696             }
7697           if (op & 0x08)
7698             {
7699               if (!first)
7700                 printf (", ");
7701               printf ("r14");
7702             }
7703           printf ("}");
7704         }
7705       else if (op == 0xb0)
7706         printf (_("     finish"));
7707       else if (op == 0xb1)
7708         {
7709           GET_OP (op2);
7710           if (op2 == 0 || (op2 & 0xf0) != 0)
7711             printf (_("[Spare]"));
7712           else
7713             {
7714               unsigned int mask = op2 & 0x0f;
7715               int first = 1;
7716               int i;
7717
7718               printf ("pop {");
7719               for (i = 0; i < 12; i++)
7720                 if (mask & (1 << i))
7721                   {
7722                     if (first)
7723                       first = 0;
7724                     else
7725                       printf (", ");
7726                     printf ("r%d", i);
7727                   }
7728               printf ("}");
7729             }
7730         }
7731       else if (op == 0xb2)
7732         {
7733           unsigned char buf[9];
7734           unsigned int i, len;
7735           unsigned long offset;
7736
7737           for (i = 0; i < sizeof (buf); i++)
7738             {
7739               GET_OP (buf[i]);
7740               if ((buf[i] & 0x80) == 0)
7741                 break;
7742             }
7743           if (i == sizeof (buf))
7744             printf (_("corrupt change to vsp"));
7745           else
7746             {
7747               offset = read_uleb128 (buf, &len, buf + i + 1);
7748               assert (len == i + 1);
7749               offset = offset * 4 + 0x204;
7750               printf ("vsp = vsp + %ld", offset);
7751             }
7752         }
7753       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7754         {
7755           unsigned int first, last;
7756
7757           GET_OP (op2);
7758           first = op2 >> 4;
7759           last = op2 & 0x0f;
7760           if (op == 0xc8)
7761             first = first + 16;
7762           printf ("pop {D%d", first);
7763           if (last)
7764             printf ("-D%d", first + last);
7765           printf ("}");
7766         }
7767       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7768         {
7769           unsigned int count = op & 0x07;
7770
7771           printf ("pop {D8");
7772           if (count)
7773             printf ("-D%d", 8 + count);
7774           printf ("}");
7775         }
7776       else if (op >= 0xc0 && op <= 0xc5)
7777         {
7778           unsigned int count = op & 0x07;
7779
7780           printf ("     pop {wR10");
7781           if (count)
7782             printf ("-wR%d", 10 + count);
7783           printf ("}");
7784         }
7785       else if (op == 0xc6)
7786         {
7787           unsigned int first, last;
7788
7789           GET_OP (op2);
7790           first = op2 >> 4;
7791           last = op2 & 0x0f;
7792           printf ("pop {wR%d", first);
7793           if (last)
7794             printf ("-wR%d", first + last);
7795           printf ("}");
7796         }
7797       else if (op == 0xc7)
7798         {
7799           GET_OP (op2);
7800           if (op2 == 0 || (op2 & 0xf0) != 0)
7801             printf (_("[Spare]"));
7802           else
7803             {
7804               unsigned int mask = op2 & 0x0f;
7805               int first = 1;
7806               int i;
7807
7808               printf ("pop {");
7809               for (i = 0; i < 4; i++)
7810                 if (mask & (1 << i))
7811                   {
7812                     if (first)
7813                       first = 0;
7814                     else
7815                       printf (", ");
7816                     printf ("wCGR%d", i);
7817                   }
7818               printf ("}");
7819             }
7820         }
7821       else
7822         printf (_("     [unsupported opcode]"));
7823       printf ("\n");
7824     }
7825 }
7826
7827 static void
7828 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
7829                               unsigned int               word,
7830                               unsigned int               remaining,
7831                               unsigned int               more_words,
7832                               bfd_vma                    data_offset,
7833                               Elf_Internal_Shdr *        data_sec,
7834                               struct arm_section *       data_arm_sec)
7835 {
7836   struct absaddr addr;
7837
7838   /* Decode the unwinding instructions.  */
7839   while (1)
7840     {
7841       unsigned int op, op2;
7842
7843       ADVANCE;
7844       if (remaining == 0)
7845         break;
7846       remaining--;
7847       op = word >> 24;
7848       word <<= 8;
7849
7850       printf ("  0x%02x ", op);
7851
7852       if ((op & 0xc0) == 0x00)
7853         {
7854           int offset = ((op & 0x3f) << 3) + 8;
7855           printf ("     sp = sp + %d", offset);
7856         }
7857       else if ((op & 0xc0) == 0x80)
7858         {
7859           GET_OP (op2);
7860           if (op == 0x80 && op2 == 0)
7861             printf (_("Refuse to unwind"));
7862           else
7863             {
7864               unsigned int mask = ((op & 0x1f) << 8) | op2;
7865               if (op & 0x20)
7866                 printf ("pop compact {");
7867               else
7868                 printf ("pop {");
7869
7870               decode_tic6x_unwind_regmask (mask);
7871               printf("}");
7872             }
7873         }
7874       else if ((op & 0xf0) == 0xc0)
7875         {
7876           unsigned int reg;
7877           unsigned int nregs;
7878           unsigned int i;
7879           const char *name;
7880           struct
7881           {
7882               unsigned int offset;
7883               unsigned int reg;
7884           } regpos[16];
7885
7886           /* Scan entire instruction first so that GET_OP output is not
7887              interleaved with disassembly.  */
7888           nregs = 0;
7889           for (i = 0; nregs < (op & 0xf); i++)
7890             {
7891               GET_OP (op2);
7892               reg = op2 >> 4;
7893               if (reg != 0xf)
7894                 {
7895                   regpos[nregs].offset = i * 2;
7896                   regpos[nregs].reg = reg;
7897                   nregs++;
7898                 }
7899
7900               reg = op2 & 0xf;
7901               if (reg != 0xf)
7902                 {
7903                   regpos[nregs].offset = i * 2 + 1;
7904                   regpos[nregs].reg = reg;
7905                   nregs++;
7906                 }
7907             }
7908
7909           printf (_("pop frame {"));
7910           reg = nregs - 1;
7911           for (i = i * 2; i > 0; i--)
7912             {
7913               if (regpos[reg].offset == i - 1)
7914                 {
7915                   name = tic6x_unwind_regnames[regpos[reg].reg];
7916                   if (reg > 0)
7917                     reg--;
7918                 }
7919               else
7920                 name = _("[pad]");
7921
7922               fputs (name, stdout);
7923               if (i > 1)
7924                 printf (", ");
7925             }
7926
7927           printf ("}");
7928         }
7929       else if (op == 0xd0)
7930         printf ("     MOV FP, SP");
7931       else if (op == 0xd1)
7932         printf ("     __c6xabi_pop_rts");
7933       else if (op == 0xd2)
7934         {
7935           unsigned char buf[9];
7936           unsigned int i, len;
7937           unsigned long offset;
7938
7939           for (i = 0; i < sizeof (buf); i++)
7940             {
7941               GET_OP (buf[i]);
7942               if ((buf[i] & 0x80) == 0)
7943                 break;
7944             }
7945           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
7946           if (i == sizeof (buf))
7947             {
7948               printf ("<corrupt sp adjust>\n");
7949               warn (_("Corrupt stack pointer adjustment detected\n"));
7950               return;
7951             }
7952
7953           offset = read_uleb128 (buf, &len, buf + i + 1);
7954           assert (len == i + 1);
7955           offset = offset * 8 + 0x408;
7956           printf (_("sp = sp + %ld"), offset);
7957         }
7958       else if ((op & 0xf0) == 0xe0)
7959         {
7960           if ((op & 0x0f) == 7)
7961             printf ("     RETURN");
7962           else
7963             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7964         }
7965       else
7966         {
7967           printf (_("     [unsupported opcode]"));
7968         }
7969       putchar ('\n');
7970     }
7971 }
7972
7973 static bfd_vma
7974 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7975 {
7976   bfd_vma offset;
7977
7978   offset = word & 0x7fffffff;
7979   if (offset & 0x40000000)
7980     offset |= ~ (bfd_vma) 0x7fffffff;
7981
7982   if (elf_header.e_machine == EM_TI_C6000)
7983     offset <<= 1;
7984
7985   return offset + where;
7986 }
7987
7988 static void
7989 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7990                    unsigned int               word,
7991                    unsigned int               remaining,
7992                    bfd_vma                    data_offset,
7993                    Elf_Internal_Shdr *        data_sec,
7994                    struct arm_section *       data_arm_sec)
7995 {
7996   int per_index;
7997   unsigned int more_words = 0;
7998   struct absaddr addr;
7999   bfd_vma sym_name = (bfd_vma) -1;
8000
8001   if (remaining == 0)
8002     {
8003       /* Fetch the first word.
8004          Note - when decoding an object file the address extracted
8005          here will always be 0.  So we also pass in the sym_name
8006          parameter so that we can find the symbol associated with
8007          the personality routine.  */
8008       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8009                                      & word, & addr, & sym_name))
8010         return;
8011
8012       remaining = 4;
8013     }
8014
8015   if ((word & 0x80000000) == 0)
8016     {
8017       /* Expand prel31 for personality routine.  */
8018       bfd_vma fn;
8019       const char *procname;
8020
8021       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8022       printf (_("  Personality routine: "));
8023       if (fn == 0
8024           && addr.section == SHN_UNDEF && addr.offset == 0
8025           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8026         {
8027           procname = aux->strtab + sym_name;
8028           print_vma (fn, PREFIX_HEX);
8029           if (procname)
8030             {
8031               fputs (" <", stdout);
8032               fputs (procname, stdout);
8033               fputc ('>', stdout);
8034             }
8035         }
8036       else
8037         procname = arm_print_vma_and_name (aux, fn, addr);
8038       fputc ('\n', stdout);
8039
8040       /* The GCC personality routines use the standard compact
8041          encoding, starting with one byte giving the number of
8042          words.  */
8043       if (procname != NULL
8044           && (const_strneq (procname, "__gcc_personality_v0")
8045               || const_strneq (procname, "__gxx_personality_v0")
8046               || const_strneq (procname, "__gcj_personality_v0")
8047               || const_strneq (procname, "__gnu_objc_personality_v0")))
8048         {
8049           remaining = 0;
8050           more_words = 1;
8051           ADVANCE;
8052           if (!remaining)
8053             {
8054               printf (_("  [Truncated data]\n"));
8055               return;
8056             }
8057           more_words = word >> 24;
8058           word <<= 8;
8059           remaining--;
8060           per_index = -1;
8061         }
8062       else
8063         return;
8064     }
8065   else
8066     {
8067       /* ARM EHABI Section 6.3:
8068
8069          An exception-handling table entry for the compact model looks like:
8070
8071            31 30-28 27-24 23-0
8072            -- ----- ----- ----
8073             1   0   index Data for personalityRoutine[index]    */
8074
8075       if (elf_header.e_machine == EM_ARM
8076           && (word & 0x70000000))
8077         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8078
8079       per_index = (word >> 24) & 0x7f;
8080       printf (_("  Compact model index: %d\n"), per_index);
8081       if (per_index == 0)
8082         {
8083           more_words = 0;
8084           word <<= 8;
8085           remaining--;
8086         }
8087       else if (per_index < 3)
8088         {
8089           more_words = (word >> 16) & 0xff;
8090           word <<= 16;
8091           remaining -= 2;
8092         }
8093     }
8094
8095   switch (elf_header.e_machine)
8096     {
8097     case EM_ARM:
8098       if (per_index < 3)
8099         {
8100           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8101                                       data_offset, data_sec, data_arm_sec);
8102         }
8103       else
8104         {
8105           warn (_("Unknown ARM compact model index encountered\n"));
8106           printf (_("  [reserved]\n"));
8107         }
8108       break;
8109
8110     case EM_TI_C6000:
8111       if (per_index < 3)
8112         {
8113           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8114                                         data_offset, data_sec, data_arm_sec);
8115         }
8116       else if (per_index < 5)
8117         {
8118           if (((word >> 17) & 0x7f) == 0x7f)
8119             printf (_("  Restore stack from frame pointer\n"));
8120           else
8121             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8122           printf (_("  Registers restored: "));
8123           if (per_index == 4)
8124             printf (" (compact) ");
8125           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8126           putchar ('\n');
8127           printf (_("  Return register: %s\n"),
8128                   tic6x_unwind_regnames[word & 0xf]);
8129         }
8130       else
8131         printf (_("  [reserved (%d)]\n"), per_index);
8132       break;
8133
8134     default:
8135       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8136              elf_header.e_machine);
8137     }
8138
8139   /* Decode the descriptors.  Not implemented.  */
8140 }
8141
8142 static void
8143 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8144 {
8145   struct arm_section exidx_arm_sec, extab_arm_sec;
8146   unsigned int i, exidx_len;
8147   unsigned long j, nfuns;
8148
8149   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8150   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8151   exidx_len = exidx_sec->sh_size / 8;
8152
8153   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8154   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8155     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8156       aux->funtab[nfuns++] = aux->symtab[j];
8157   aux->nfuns = nfuns;
8158   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8159
8160   for (i = 0; i < exidx_len; i++)
8161     {
8162       unsigned int exidx_fn, exidx_entry;
8163       struct absaddr fn_addr, entry_addr;
8164       bfd_vma fn;
8165
8166       fputc ('\n', stdout);
8167
8168       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8169                                      8 * i, & exidx_fn, & fn_addr, NULL)
8170           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8171                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8172         {
8173           free (aux->funtab);
8174           arm_free_section (& exidx_arm_sec);
8175           arm_free_section (& extab_arm_sec);
8176           return;
8177         }
8178
8179       /* ARM EHABI, Section 5:
8180          An index table entry consists of 2 words.
8181          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8182       if (exidx_fn & 0x80000000)
8183         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8184
8185       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8186
8187       arm_print_vma_and_name (aux, fn, fn_addr);
8188       fputs (": ", stdout);
8189
8190       if (exidx_entry == 1)
8191         {
8192           print_vma (exidx_entry, PREFIX_HEX);
8193           fputs (" [cantunwind]\n", stdout);
8194         }
8195       else if (exidx_entry & 0x80000000)
8196         {
8197           print_vma (exidx_entry, PREFIX_HEX);
8198           fputc ('\n', stdout);
8199           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8200         }
8201       else
8202         {
8203           bfd_vma table, table_offset = 0;
8204           Elf_Internal_Shdr *table_sec;
8205
8206           fputs ("@", stdout);
8207           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8208           print_vma (table, PREFIX_HEX);
8209           printf ("\n");
8210
8211           /* Locate the matching .ARM.extab.  */
8212           if (entry_addr.section != SHN_UNDEF
8213               && entry_addr.section < elf_header.e_shnum)
8214             {
8215               table_sec = section_headers + entry_addr.section;
8216               table_offset = entry_addr.offset;
8217             }
8218           else
8219             {
8220               table_sec = find_section_by_address (table);
8221               if (table_sec != NULL)
8222                 table_offset = table - table_sec->sh_addr;
8223             }
8224           if (table_sec == NULL)
8225             {
8226               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8227                     (unsigned long) table);
8228               continue;
8229             }
8230           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8231                              &extab_arm_sec);
8232         }
8233     }
8234
8235   printf ("\n");
8236
8237   free (aux->funtab);
8238   arm_free_section (&exidx_arm_sec);
8239   arm_free_section (&extab_arm_sec);
8240 }
8241
8242 /* Used for both ARM and C6X unwinding tables.  */
8243
8244 static void
8245 arm_process_unwind (FILE *file)
8246 {
8247   struct arm_unw_aux_info aux;
8248   Elf_Internal_Shdr *unwsec = NULL;
8249   Elf_Internal_Shdr *strsec;
8250   Elf_Internal_Shdr *sec;
8251   unsigned long i;
8252   unsigned int sec_type;
8253
8254   switch (elf_header.e_machine)
8255     {
8256     case EM_ARM:
8257       sec_type = SHT_ARM_EXIDX;
8258       break;
8259
8260     case EM_TI_C6000:
8261       sec_type = SHT_C6000_UNWIND;
8262       break;
8263
8264     default:
8265       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8266              elf_header.e_machine);
8267       return;
8268     }
8269
8270   if (string_table == NULL)
8271     return;
8272
8273   memset (& aux, 0, sizeof (aux));
8274   aux.file = file;
8275
8276   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8277     {
8278       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8279         {
8280           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8281
8282           strsec = section_headers + sec->sh_link;
8283
8284           /* PR binutils/17531 file: 011-12666-0.004.  */
8285           if (aux.strtab != NULL)
8286             {
8287               error (_("Multiple string tables found in file.\n"));
8288               free (aux.strtab);
8289             }
8290           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8291                                  1, strsec->sh_size, _("string table"));
8292           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8293         }
8294       else if (sec->sh_type == sec_type)
8295         unwsec = sec;
8296     }
8297
8298   if (unwsec == NULL)
8299     printf (_("\nThere are no unwind sections in this file.\n"));
8300   else
8301     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8302       {
8303         if (sec->sh_type == sec_type)
8304           {
8305             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8306                     printable_section_name (sec),
8307                     (unsigned long) sec->sh_offset,
8308                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8309
8310             dump_arm_unwind (&aux, sec);
8311           }
8312       }
8313
8314   if (aux.symtab)
8315     free (aux.symtab);
8316   if (aux.strtab)
8317     free ((char *) aux.strtab);
8318 }
8319
8320 static void
8321 process_unwind (FILE * file)
8322 {
8323   struct unwind_handler
8324   {
8325     int machtype;
8326     void (* handler)(FILE *);
8327   } handlers[] =
8328   {
8329     { EM_ARM, arm_process_unwind },
8330     { EM_IA_64, ia64_process_unwind },
8331     { EM_PARISC, hppa_process_unwind },
8332     { EM_TI_C6000, arm_process_unwind },
8333     { 0, 0 }
8334   };
8335   int i;
8336
8337   if (!do_unwind)
8338     return;
8339
8340   for (i = 0; handlers[i].handler != NULL; i++)
8341     if (elf_header.e_machine == handlers[i].machtype)
8342       {
8343         handlers[i].handler (file);
8344         return;
8345       }
8346
8347   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8348           get_machine_name (elf_header.e_machine));
8349 }
8350
8351 static void
8352 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8353 {
8354   switch (entry->d_tag)
8355     {
8356     case DT_MIPS_FLAGS:
8357       if (entry->d_un.d_val == 0)
8358         printf (_("NONE"));
8359       else
8360         {
8361           static const char * opts[] =
8362           {
8363             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8364             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8365             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8366             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8367             "RLD_ORDER_SAFE"
8368           };
8369           unsigned int cnt;
8370           int first = 1;
8371
8372           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8373             if (entry->d_un.d_val & (1 << cnt))
8374               {
8375                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8376                 first = 0;
8377               }
8378         }
8379       break;
8380
8381     case DT_MIPS_IVERSION:
8382       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8383         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8384       else
8385         {
8386           char buf[40];
8387           sprintf_vma (buf, entry->d_un.d_ptr);
8388           /* Note: coded this way so that there is a single string for translation.  */
8389           printf (_("<corrupt: %s>"), buf);
8390         }
8391       break;
8392
8393     case DT_MIPS_TIME_STAMP:
8394       {
8395         char timebuf[20];
8396         struct tm * tmp;
8397         time_t atime = entry->d_un.d_val;
8398
8399         tmp = gmtime (&atime);
8400         /* PR 17531: file: 6accc532.  */
8401         if (tmp == NULL)
8402           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8403         else
8404           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8405                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8406                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8407         printf (_("Time Stamp: %s"), timebuf);
8408       }
8409       break;
8410
8411     case DT_MIPS_RLD_VERSION:
8412     case DT_MIPS_LOCAL_GOTNO:
8413     case DT_MIPS_CONFLICTNO:
8414     case DT_MIPS_LIBLISTNO:
8415     case DT_MIPS_SYMTABNO:
8416     case DT_MIPS_UNREFEXTNO:
8417     case DT_MIPS_HIPAGENO:
8418     case DT_MIPS_DELTA_CLASS_NO:
8419     case DT_MIPS_DELTA_INSTANCE_NO:
8420     case DT_MIPS_DELTA_RELOC_NO:
8421     case DT_MIPS_DELTA_SYM_NO:
8422     case DT_MIPS_DELTA_CLASSSYM_NO:
8423     case DT_MIPS_COMPACT_SIZE:
8424       print_vma (entry->d_un.d_ptr, DEC);
8425       break;
8426
8427     default:
8428       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8429     }
8430     putchar ('\n');
8431 }
8432
8433 static void
8434 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8435 {
8436   switch (entry->d_tag)
8437     {
8438     case DT_HP_DLD_FLAGS:
8439       {
8440         static struct
8441         {
8442           long int bit;
8443           const char * str;
8444         }
8445         flags[] =
8446         {
8447           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8448           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8449           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8450           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8451           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8452           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8453           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8454           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8455           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8456           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8457           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8458           { DT_HP_GST, "HP_GST" },
8459           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8460           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8461           { DT_HP_NODELETE, "HP_NODELETE" },
8462           { DT_HP_GROUP, "HP_GROUP" },
8463           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8464         };
8465         int first = 1;
8466         size_t cnt;
8467         bfd_vma val = entry->d_un.d_val;
8468
8469         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8470           if (val & flags[cnt].bit)
8471             {
8472               if (! first)
8473                 putchar (' ');
8474               fputs (flags[cnt].str, stdout);
8475               first = 0;
8476               val ^= flags[cnt].bit;
8477             }
8478
8479         if (val != 0 || first)
8480           {
8481             if (! first)
8482               putchar (' ');
8483             print_vma (val, HEX);
8484           }
8485       }
8486       break;
8487
8488     default:
8489       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8490       break;
8491     }
8492   putchar ('\n');
8493 }
8494
8495 #ifdef BFD64
8496
8497 /* VMS vs Unix time offset and factor.  */
8498
8499 #define VMS_EPOCH_OFFSET 35067168000000000LL
8500 #define VMS_GRANULARITY_FACTOR 10000000
8501
8502 /* Display a VMS time in a human readable format.  */
8503
8504 static void
8505 print_vms_time (bfd_int64_t vmstime)
8506 {
8507   struct tm *tm;
8508   time_t unxtime;
8509
8510   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8511   tm = gmtime (&unxtime);
8512   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8513           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8514           tm->tm_hour, tm->tm_min, tm->tm_sec);
8515 }
8516 #endif /* BFD64 */
8517
8518 static void
8519 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8520 {
8521   switch (entry->d_tag)
8522     {
8523     case DT_IA_64_PLT_RESERVE:
8524       /* First 3 slots reserved.  */
8525       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8526       printf (" -- ");
8527       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8528       break;
8529
8530     case DT_IA_64_VMS_LINKTIME:
8531 #ifdef BFD64
8532       print_vms_time (entry->d_un.d_val);
8533 #endif
8534       break;
8535
8536     case DT_IA_64_VMS_LNKFLAGS:
8537       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8538       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8539         printf (" CALL_DEBUG");
8540       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8541         printf (" NOP0BUFS");
8542       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8543         printf (" P0IMAGE");
8544       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8545         printf (" MKTHREADS");
8546       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8547         printf (" UPCALLS");
8548       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8549         printf (" IMGSTA");
8550       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8551         printf (" INITIALIZE");
8552       if (entry->d_un.d_val & VMS_LF_MAIN)
8553         printf (" MAIN");
8554       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8555         printf (" EXE_INIT");
8556       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8557         printf (" TBK_IN_IMG");
8558       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8559         printf (" DBG_IN_IMG");
8560       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8561         printf (" TBK_IN_DSF");
8562       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8563         printf (" DBG_IN_DSF");
8564       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8565         printf (" SIGNATURES");
8566       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8567         printf (" REL_SEG_OFF");
8568       break;
8569
8570     default:
8571       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8572       break;
8573     }
8574   putchar ('\n');
8575 }
8576
8577 static int
8578 get_32bit_dynamic_section (FILE * file)
8579 {
8580   Elf32_External_Dyn * edyn;
8581   Elf32_External_Dyn * ext;
8582   Elf_Internal_Dyn * entry;
8583
8584   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8585                                           dynamic_size, _("dynamic section"));
8586   if (!edyn)
8587     return 0;
8588
8589   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8590      might not have the luxury of section headers.  Look for the DT_NULL
8591      terminator to determine the number of entries.  */
8592   for (ext = edyn, dynamic_nent = 0;
8593        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8594        ext++)
8595     {
8596       dynamic_nent++;
8597       if (BYTE_GET (ext->d_tag) == DT_NULL)
8598         break;
8599     }
8600
8601   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8602                                                   sizeof (* entry));
8603   if (dynamic_section == NULL)
8604     {
8605       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8606              (unsigned long) dynamic_nent);
8607       free (edyn);
8608       return 0;
8609     }
8610
8611   for (ext = edyn, entry = dynamic_section;
8612        entry < dynamic_section + dynamic_nent;
8613        ext++, entry++)
8614     {
8615       entry->d_tag      = BYTE_GET (ext->d_tag);
8616       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8617     }
8618
8619   free (edyn);
8620
8621   return 1;
8622 }
8623
8624 static int
8625 get_64bit_dynamic_section (FILE * file)
8626 {
8627   Elf64_External_Dyn * edyn;
8628   Elf64_External_Dyn * ext;
8629   Elf_Internal_Dyn * entry;
8630
8631   /* Read in the data.  */
8632   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8633                                           dynamic_size, _("dynamic section"));
8634   if (!edyn)
8635     return 0;
8636
8637   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8638      might not have the luxury of section headers.  Look for the DT_NULL
8639      terminator to determine the number of entries.  */
8640   for (ext = edyn, dynamic_nent = 0;
8641        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8642        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8643        ext++)
8644     {
8645       dynamic_nent++;
8646       if (BYTE_GET (ext->d_tag) == DT_NULL)
8647         break;
8648     }
8649
8650   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8651                                                   sizeof (* entry));
8652   if (dynamic_section == NULL)
8653     {
8654       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8655              (unsigned long) dynamic_nent);
8656       free (edyn);
8657       return 0;
8658     }
8659
8660   /* Convert from external to internal formats.  */
8661   for (ext = edyn, entry = dynamic_section;
8662        entry < dynamic_section + dynamic_nent;
8663        ext++, entry++)
8664     {
8665       entry->d_tag      = BYTE_GET (ext->d_tag);
8666       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8667     }
8668
8669   free (edyn);
8670
8671   return 1;
8672 }
8673
8674 static void
8675 print_dynamic_flags (bfd_vma flags)
8676 {
8677   int first = 1;
8678
8679   while (flags)
8680     {
8681       bfd_vma flag;
8682
8683       flag = flags & - flags;
8684       flags &= ~ flag;
8685
8686       if (first)
8687         first = 0;
8688       else
8689         putc (' ', stdout);
8690
8691       switch (flag)
8692         {
8693         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8694         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8695         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8696         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8697         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8698         default:                fputs (_("unknown"), stdout); break;
8699         }
8700     }
8701   puts ("");
8702 }
8703
8704 /* Parse and display the contents of the dynamic section.  */
8705
8706 static int
8707 process_dynamic_section (FILE * file)
8708 {
8709   Elf_Internal_Dyn * entry;
8710
8711   if (dynamic_size == 0)
8712     {
8713       if (do_dynamic)
8714         printf (_("\nThere is no dynamic section in this file.\n"));
8715
8716       return 1;
8717     }
8718
8719   if (is_32bit_elf)
8720     {
8721       if (! get_32bit_dynamic_section (file))
8722         return 0;
8723     }
8724   else if (! get_64bit_dynamic_section (file))
8725     return 0;
8726
8727   /* Find the appropriate symbol table.  */
8728   if (dynamic_symbols == NULL)
8729     {
8730       for (entry = dynamic_section;
8731            entry < dynamic_section + dynamic_nent;
8732            ++entry)
8733         {
8734           Elf_Internal_Shdr section;
8735
8736           if (entry->d_tag != DT_SYMTAB)
8737             continue;
8738
8739           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8740
8741           /* Since we do not know how big the symbol table is,
8742              we default to reading in the entire file (!) and
8743              processing that.  This is overkill, I know, but it
8744              should work.  */
8745           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8746
8747           if (archive_file_offset != 0)
8748             section.sh_size = archive_file_size - section.sh_offset;
8749           else
8750             {
8751               if (fseek (file, 0, SEEK_END))
8752                 error (_("Unable to seek to end of file!\n"));
8753
8754               section.sh_size = ftell (file) - section.sh_offset;
8755             }
8756
8757           if (is_32bit_elf)
8758             section.sh_entsize = sizeof (Elf32_External_Sym);
8759           else
8760             section.sh_entsize = sizeof (Elf64_External_Sym);
8761           section.sh_name = string_table_length;
8762
8763           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8764           if (num_dynamic_syms < 1)
8765             {
8766               error (_("Unable to determine the number of symbols to load\n"));
8767               continue;
8768             }
8769         }
8770     }
8771
8772   /* Similarly find a string table.  */
8773   if (dynamic_strings == NULL)
8774     {
8775       for (entry = dynamic_section;
8776            entry < dynamic_section + dynamic_nent;
8777            ++entry)
8778         {
8779           unsigned long offset;
8780           long str_tab_len;
8781
8782           if (entry->d_tag != DT_STRTAB)
8783             continue;
8784
8785           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8786
8787           /* Since we do not know how big the string table is,
8788              we default to reading in the entire file (!) and
8789              processing that.  This is overkill, I know, but it
8790              should work.  */
8791
8792           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8793
8794           if (archive_file_offset != 0)
8795             str_tab_len = archive_file_size - offset;
8796           else
8797             {
8798               if (fseek (file, 0, SEEK_END))
8799                 error (_("Unable to seek to end of file\n"));
8800               str_tab_len = ftell (file) - offset;
8801             }
8802
8803           if (str_tab_len < 1)
8804             {
8805               error
8806                 (_("Unable to determine the length of the dynamic string table\n"));
8807               continue;
8808             }
8809
8810           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8811                                                str_tab_len,
8812                                                _("dynamic string table"));
8813           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8814           break;
8815         }
8816     }
8817
8818   /* And find the syminfo section if available.  */
8819   if (dynamic_syminfo == NULL)
8820     {
8821       unsigned long syminsz = 0;
8822
8823       for (entry = dynamic_section;
8824            entry < dynamic_section + dynamic_nent;
8825            ++entry)
8826         {
8827           if (entry->d_tag == DT_SYMINENT)
8828             {
8829               /* Note: these braces are necessary to avoid a syntax
8830                  error from the SunOS4 C compiler.  */
8831               /* PR binutils/17531: A corrupt file can trigger this test.
8832                  So do not use an assert, instead generate an error message.  */
8833               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8834                 error (_("Bad value (%d) for SYMINENT entry\n"),
8835                        (int) entry->d_un.d_val);
8836             }
8837           else if (entry->d_tag == DT_SYMINSZ)
8838             syminsz = entry->d_un.d_val;
8839           else if (entry->d_tag == DT_SYMINFO)
8840             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8841                                                       syminsz);
8842         }
8843
8844       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8845         {
8846           Elf_External_Syminfo * extsyminfo;
8847           Elf_External_Syminfo * extsym;
8848           Elf_Internal_Syminfo * syminfo;
8849
8850           /* There is a syminfo section.  Read the data.  */
8851           extsyminfo = (Elf_External_Syminfo *)
8852               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8853                         _("symbol information"));
8854           if (!extsyminfo)
8855             return 0;
8856
8857           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8858           if (dynamic_syminfo == NULL)
8859             {
8860               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8861                      (unsigned long) syminsz);
8862               return 0;
8863             }
8864
8865           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8866           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8867                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8868                ++syminfo, ++extsym)
8869             {
8870               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8871               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8872             }
8873
8874           free (extsyminfo);
8875         }
8876     }
8877
8878   if (do_dynamic && dynamic_addr)
8879     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8880             dynamic_addr, (unsigned long) dynamic_nent);
8881   if (do_dynamic)
8882     printf (_("  Tag        Type                         Name/Value\n"));
8883
8884   for (entry = dynamic_section;
8885        entry < dynamic_section + dynamic_nent;
8886        entry++)
8887     {
8888       if (do_dynamic)
8889         {
8890           const char * dtype;
8891
8892           putchar (' ');
8893           print_vma (entry->d_tag, FULL_HEX);
8894           dtype = get_dynamic_type (entry->d_tag);
8895           printf (" (%s)%*s", dtype,
8896                   ((is_32bit_elf ? 27 : 19)
8897                    - (int) strlen (dtype)),
8898                   " ");
8899         }
8900
8901       switch (entry->d_tag)
8902         {
8903         case DT_FLAGS:
8904           if (do_dynamic)
8905             print_dynamic_flags (entry->d_un.d_val);
8906           break;
8907
8908         case DT_AUXILIARY:
8909         case DT_FILTER:
8910         case DT_CONFIG:
8911         case DT_DEPAUDIT:
8912         case DT_AUDIT:
8913           if (do_dynamic)
8914             {
8915               switch (entry->d_tag)
8916                 {
8917                 case DT_AUXILIARY:
8918                   printf (_("Auxiliary library"));
8919                   break;
8920
8921                 case DT_FILTER:
8922                   printf (_("Filter library"));
8923                   break;
8924
8925                 case DT_CONFIG:
8926                   printf (_("Configuration file"));
8927                   break;
8928
8929                 case DT_DEPAUDIT:
8930                   printf (_("Dependency audit library"));
8931                   break;
8932
8933                 case DT_AUDIT:
8934                   printf (_("Audit library"));
8935                   break;
8936                 }
8937
8938               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8939                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8940               else
8941                 {
8942                   printf (": ");
8943                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8944                   putchar ('\n');
8945                 }
8946             }
8947           break;
8948
8949         case DT_FEATURE:
8950           if (do_dynamic)
8951             {
8952               printf (_("Flags:"));
8953
8954               if (entry->d_un.d_val == 0)
8955                 printf (_(" None\n"));
8956               else
8957                 {
8958                   unsigned long int val = entry->d_un.d_val;
8959
8960                   if (val & DTF_1_PARINIT)
8961                     {
8962                       printf (" PARINIT");
8963                       val ^= DTF_1_PARINIT;
8964                     }
8965                   if (val & DTF_1_CONFEXP)
8966                     {
8967                       printf (" CONFEXP");
8968                       val ^= DTF_1_CONFEXP;
8969                     }
8970                   if (val != 0)
8971                     printf (" %lx", val);
8972                   puts ("");
8973                 }
8974             }
8975           break;
8976
8977         case DT_POSFLAG_1:
8978           if (do_dynamic)
8979             {
8980               printf (_("Flags:"));
8981
8982               if (entry->d_un.d_val == 0)
8983                 printf (_(" None\n"));
8984               else
8985                 {
8986                   unsigned long int val = entry->d_un.d_val;
8987
8988                   if (val & DF_P1_LAZYLOAD)
8989                     {
8990                       printf (" LAZYLOAD");
8991                       val ^= DF_P1_LAZYLOAD;
8992                     }
8993                   if (val & DF_P1_GROUPPERM)
8994                     {
8995                       printf (" GROUPPERM");
8996                       val ^= DF_P1_GROUPPERM;
8997                     }
8998                   if (val != 0)
8999                     printf (" %lx", val);
9000                   puts ("");
9001                 }
9002             }
9003           break;
9004
9005         case DT_FLAGS_1:
9006           if (do_dynamic)
9007             {
9008               printf (_("Flags:"));
9009               if (entry->d_un.d_val == 0)
9010                 printf (_(" None\n"));
9011               else
9012                 {
9013                   unsigned long int val = entry->d_un.d_val;
9014
9015                   if (val & DF_1_NOW)
9016                     {
9017                       printf (" NOW");
9018                       val ^= DF_1_NOW;
9019                     }
9020                   if (val & DF_1_GLOBAL)
9021                     {
9022                       printf (" GLOBAL");
9023                       val ^= DF_1_GLOBAL;
9024                     }
9025                   if (val & DF_1_GROUP)
9026                     {
9027                       printf (" GROUP");
9028                       val ^= DF_1_GROUP;
9029                     }
9030                   if (val & DF_1_NODELETE)
9031                     {
9032                       printf (" NODELETE");
9033                       val ^= DF_1_NODELETE;
9034                     }
9035                   if (val & DF_1_LOADFLTR)
9036                     {
9037                       printf (" LOADFLTR");
9038                       val ^= DF_1_LOADFLTR;
9039                     }
9040                   if (val & DF_1_INITFIRST)
9041                     {
9042                       printf (" INITFIRST");
9043                       val ^= DF_1_INITFIRST;
9044                     }
9045                   if (val & DF_1_NOOPEN)
9046                     {
9047                       printf (" NOOPEN");
9048                       val ^= DF_1_NOOPEN;
9049                     }
9050                   if (val & DF_1_ORIGIN)
9051                     {
9052                       printf (" ORIGIN");
9053                       val ^= DF_1_ORIGIN;
9054                     }
9055                   if (val & DF_1_DIRECT)
9056                     {
9057                       printf (" DIRECT");
9058                       val ^= DF_1_DIRECT;
9059                     }
9060                   if (val & DF_1_TRANS)
9061                     {
9062                       printf (" TRANS");
9063                       val ^= DF_1_TRANS;
9064                     }
9065                   if (val & DF_1_INTERPOSE)
9066                     {
9067                       printf (" INTERPOSE");
9068                       val ^= DF_1_INTERPOSE;
9069                     }
9070                   if (val & DF_1_NODEFLIB)
9071                     {
9072                       printf (" NODEFLIB");
9073                       val ^= DF_1_NODEFLIB;
9074                     }
9075                   if (val & DF_1_NODUMP)
9076                     {
9077                       printf (" NODUMP");
9078                       val ^= DF_1_NODUMP;
9079                     }
9080                   if (val & DF_1_CONFALT)
9081                     {
9082                       printf (" CONFALT");
9083                       val ^= DF_1_CONFALT;
9084                     }
9085                   if (val & DF_1_ENDFILTEE)
9086                     {
9087                       printf (" ENDFILTEE");
9088                       val ^= DF_1_ENDFILTEE;
9089                     }
9090                   if (val & DF_1_DISPRELDNE)
9091                     {
9092                       printf (" DISPRELDNE");
9093                       val ^= DF_1_DISPRELDNE;
9094                     }
9095                   if (val & DF_1_DISPRELPND)
9096                     {
9097                       printf (" DISPRELPND");
9098                       val ^= DF_1_DISPRELPND;
9099                     }
9100                   if (val & DF_1_NODIRECT)
9101                     {
9102                       printf (" NODIRECT");
9103                       val ^= DF_1_NODIRECT;
9104                     }
9105                   if (val & DF_1_IGNMULDEF)
9106                     {
9107                       printf (" IGNMULDEF");
9108                       val ^= DF_1_IGNMULDEF;
9109                     }
9110                   if (val & DF_1_NOKSYMS)
9111                     {
9112                       printf (" NOKSYMS");
9113                       val ^= DF_1_NOKSYMS;
9114                     }
9115                   if (val & DF_1_NOHDR)
9116                     {
9117                       printf (" NOHDR");
9118                       val ^= DF_1_NOHDR;
9119                     }
9120                   if (val & DF_1_EDITED)
9121                     {
9122                       printf (" EDITED");
9123                       val ^= DF_1_EDITED;
9124                     }
9125                   if (val & DF_1_NORELOC)
9126                     {
9127                       printf (" NORELOC");
9128                       val ^= DF_1_NORELOC;
9129                     }
9130                   if (val & DF_1_SYMINTPOSE)
9131                     {
9132                       printf (" SYMINTPOSE");
9133                       val ^= DF_1_SYMINTPOSE;
9134                     }
9135                   if (val & DF_1_GLOBAUDIT)
9136                     {
9137                       printf (" GLOBAUDIT");
9138                       val ^= DF_1_GLOBAUDIT;
9139                     }
9140                   if (val & DF_1_SINGLETON)
9141                     {
9142                       printf (" SINGLETON");
9143                       val ^= DF_1_SINGLETON;
9144                     }
9145                   if (val != 0)
9146                     printf (" %lx", val);
9147                   puts ("");
9148                 }
9149             }
9150           break;
9151
9152         case DT_PLTREL:
9153           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9154           if (do_dynamic)
9155             puts (get_dynamic_type (entry->d_un.d_val));
9156           break;
9157
9158         case DT_NULL    :
9159         case DT_NEEDED  :
9160         case DT_PLTGOT  :
9161         case DT_HASH    :
9162         case DT_STRTAB  :
9163         case DT_SYMTAB  :
9164         case DT_RELA    :
9165         case DT_INIT    :
9166         case DT_FINI    :
9167         case DT_SONAME  :
9168         case DT_RPATH   :
9169         case DT_SYMBOLIC:
9170         case DT_REL     :
9171         case DT_DEBUG   :
9172         case DT_TEXTREL :
9173         case DT_JMPREL  :
9174         case DT_RUNPATH :
9175           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9176
9177           if (do_dynamic)
9178             {
9179               char * name;
9180
9181               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9182                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9183               else
9184                 name = NULL;
9185
9186               if (name)
9187                 {
9188                   switch (entry->d_tag)
9189                     {
9190                     case DT_NEEDED:
9191                       printf (_("Shared library: [%s]"), name);
9192
9193                       if (streq (name, program_interpreter))
9194                         printf (_(" program interpreter"));
9195                       break;
9196
9197                     case DT_SONAME:
9198                       printf (_("Library soname: [%s]"), name);
9199                       break;
9200
9201                     case DT_RPATH:
9202                       printf (_("Library rpath: [%s]"), name);
9203                       break;
9204
9205                     case DT_RUNPATH:
9206                       printf (_("Library runpath: [%s]"), name);
9207                       break;
9208
9209                     default:
9210                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9211                       break;
9212                     }
9213                 }
9214               else
9215                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9216
9217               putchar ('\n');
9218             }
9219           break;
9220
9221         case DT_PLTRELSZ:
9222         case DT_RELASZ  :
9223         case DT_STRSZ   :
9224         case DT_RELSZ   :
9225         case DT_RELAENT :
9226         case DT_SYMENT  :
9227         case DT_RELENT  :
9228           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9229         case DT_PLTPADSZ:
9230         case DT_MOVEENT :
9231         case DT_MOVESZ  :
9232         case DT_INIT_ARRAYSZ:
9233         case DT_FINI_ARRAYSZ:
9234         case DT_GNU_CONFLICTSZ:
9235         case DT_GNU_LIBLISTSZ:
9236           if (do_dynamic)
9237             {
9238               print_vma (entry->d_un.d_val, UNSIGNED);
9239               printf (_(" (bytes)\n"));
9240             }
9241           break;
9242
9243         case DT_VERDEFNUM:
9244         case DT_VERNEEDNUM:
9245         case DT_RELACOUNT:
9246         case DT_RELCOUNT:
9247           if (do_dynamic)
9248             {
9249               print_vma (entry->d_un.d_val, UNSIGNED);
9250               putchar ('\n');
9251             }
9252           break;
9253
9254         case DT_SYMINSZ:
9255         case DT_SYMINENT:
9256         case DT_SYMINFO:
9257         case DT_USED:
9258         case DT_INIT_ARRAY:
9259         case DT_FINI_ARRAY:
9260           if (do_dynamic)
9261             {
9262               if (entry->d_tag == DT_USED
9263                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9264                 {
9265                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9266
9267                   if (*name)
9268                     {
9269                       printf (_("Not needed object: [%s]\n"), name);
9270                       break;
9271                     }
9272                 }
9273
9274               print_vma (entry->d_un.d_val, PREFIX_HEX);
9275               putchar ('\n');
9276             }
9277           break;
9278
9279         case DT_BIND_NOW:
9280           /* The value of this entry is ignored.  */
9281           if (do_dynamic)
9282             putchar ('\n');
9283           break;
9284
9285         case DT_GNU_PRELINKED:
9286           if (do_dynamic)
9287             {
9288               struct tm * tmp;
9289               time_t atime = entry->d_un.d_val;
9290
9291               tmp = gmtime (&atime);
9292               /* PR 17533 file: 041-1244816-0.004.  */
9293               if (tmp == NULL)
9294                 printf (_("<corrupt time val: %lx"),
9295                         (unsigned long) atime);
9296               else
9297                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9298                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9299                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9300
9301             }
9302           break;
9303
9304         case DT_GNU_HASH:
9305           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9306           if (do_dynamic)
9307             {
9308               print_vma (entry->d_un.d_val, PREFIX_HEX);
9309               putchar ('\n');
9310             }
9311           break;
9312
9313         default:
9314           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9315             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9316               entry->d_un.d_val;
9317
9318           if (do_dynamic)
9319             {
9320               switch (elf_header.e_machine)
9321                 {
9322                 case EM_MIPS:
9323                 case EM_MIPS_RS3_LE:
9324                   dynamic_section_mips_val (entry);
9325                   break;
9326                 case EM_PARISC:
9327                   dynamic_section_parisc_val (entry);
9328                   break;
9329                 case EM_IA_64:
9330                   dynamic_section_ia64_val (entry);
9331                   break;
9332                 default:
9333                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9334                   putchar ('\n');
9335                 }
9336             }
9337           break;
9338         }
9339     }
9340
9341   return 1;
9342 }
9343
9344 static char *
9345 get_ver_flags (unsigned int flags)
9346 {
9347   static char buff[32];
9348
9349   buff[0] = 0;
9350
9351   if (flags == 0)
9352     return _("none");
9353
9354   if (flags & VER_FLG_BASE)
9355     strcat (buff, "BASE ");
9356
9357   if (flags & VER_FLG_WEAK)
9358     {
9359       if (flags & VER_FLG_BASE)
9360         strcat (buff, "| ");
9361
9362       strcat (buff, "WEAK ");
9363     }
9364
9365   if (flags & VER_FLG_INFO)
9366     {
9367       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9368         strcat (buff, "| ");
9369
9370       strcat (buff, "INFO ");
9371     }
9372
9373   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9374     strcat (buff, _("| <unknown>"));
9375
9376   return buff;
9377 }
9378
9379 /* Display the contents of the version sections.  */
9380
9381 static int
9382 process_version_sections (FILE * file)
9383 {
9384   Elf_Internal_Shdr * section;
9385   unsigned i;
9386   int found = 0;
9387
9388   if (! do_version)
9389     return 1;
9390
9391   for (i = 0, section = section_headers;
9392        i < elf_header.e_shnum;
9393        i++, section++)
9394     {
9395       switch (section->sh_type)
9396         {
9397         case SHT_GNU_verdef:
9398           {
9399             Elf_External_Verdef * edefs;
9400             unsigned int idx;
9401             unsigned int cnt;
9402             char * endbuf;
9403
9404             found = 1;
9405
9406             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9407                     printable_section_name (section),
9408                     section->sh_info);
9409
9410             printf (_("  Addr: 0x"));
9411             printf_vma (section->sh_addr);
9412             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9413                     (unsigned long) section->sh_offset, section->sh_link,
9414                     printable_section_name_from_index (section->sh_link));
9415
9416             edefs = (Elf_External_Verdef *)
9417                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9418                           _("version definition section"));
9419             if (!edefs)
9420               break;
9421             endbuf = (char *) edefs + section->sh_size;
9422
9423             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9424               {
9425                 char * vstart;
9426                 Elf_External_Verdef * edef;
9427                 Elf_Internal_Verdef ent;
9428                 Elf_External_Verdaux * eaux;
9429                 Elf_Internal_Verdaux aux;
9430                 int j;
9431                 int isum;
9432
9433                 /* Check for very large indicies.  */
9434                 if (idx > (size_t) (endbuf - (char *) edefs))
9435                   break;
9436
9437                 vstart = ((char *) edefs) + idx;
9438                 if (vstart + sizeof (*edef) > endbuf)
9439                   break;
9440
9441                 edef = (Elf_External_Verdef *) vstart;
9442
9443                 ent.vd_version = BYTE_GET (edef->vd_version);
9444                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9445                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9446                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9447                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9448                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9449                 ent.vd_next    = BYTE_GET (edef->vd_next);
9450
9451                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9452                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9453
9454                 printf (_("  Index: %d  Cnt: %d  "),
9455                         ent.vd_ndx, ent.vd_cnt);
9456
9457                 /* Check for overflow.  */
9458                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9459                   break;
9460
9461                 vstart += ent.vd_aux;
9462
9463                 eaux = (Elf_External_Verdaux *) vstart;
9464
9465                 aux.vda_name = BYTE_GET (eaux->vda_name);
9466                 aux.vda_next = BYTE_GET (eaux->vda_next);
9467
9468                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9469                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9470                 else
9471                   printf (_("Name index: %ld\n"), aux.vda_name);
9472
9473                 isum = idx + ent.vd_aux;
9474
9475                 for (j = 1; j < ent.vd_cnt; j++)
9476                   {
9477                     /* Check for overflow.  */
9478                     if (aux.vda_next > (size_t) (endbuf - vstart))
9479                       break;
9480
9481                     isum   += aux.vda_next;
9482                     vstart += aux.vda_next;
9483
9484                     eaux = (Elf_External_Verdaux *) vstart;
9485                     if (vstart + sizeof (*eaux) > endbuf)
9486                       break;
9487
9488                     aux.vda_name = BYTE_GET (eaux->vda_name);
9489                     aux.vda_next = BYTE_GET (eaux->vda_next);
9490
9491                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9492                       printf (_("  %#06x: Parent %d: %s\n"),
9493                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9494                     else
9495                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9496                               isum, j, aux.vda_name);
9497                   }
9498
9499                 if (j < ent.vd_cnt)
9500                   printf (_("  Version def aux past end of section\n"));
9501
9502                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9503                 if (idx + ent.vd_next <= idx)
9504                   break;
9505
9506                 idx += ent.vd_next;
9507               }
9508
9509             if (cnt < section->sh_info)
9510               printf (_("  Version definition past end of section\n"));
9511
9512             free (edefs);
9513           }
9514           break;
9515
9516         case SHT_GNU_verneed:
9517           {
9518             Elf_External_Verneed * eneed;
9519             unsigned int idx;
9520             unsigned int cnt;
9521             char * endbuf;
9522
9523             found = 1;
9524
9525             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9526                     printable_section_name (section), section->sh_info);
9527
9528             printf (_(" Addr: 0x"));
9529             printf_vma (section->sh_addr);
9530             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9531                     (unsigned long) section->sh_offset, section->sh_link,
9532                     printable_section_name_from_index (section->sh_link));
9533
9534             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9535                                                        section->sh_offset, 1,
9536                                                        section->sh_size,
9537                                                        _("Version Needs section"));
9538             if (!eneed)
9539               break;
9540             endbuf = (char *) eneed + section->sh_size;
9541
9542             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9543               {
9544                 Elf_External_Verneed * entry;
9545                 Elf_Internal_Verneed ent;
9546                 int j;
9547                 int isum;
9548                 char * vstart;
9549
9550                 if (idx > (size_t) (endbuf - (char *) eneed))
9551                   break;
9552
9553                 vstart = ((char *) eneed) + idx;
9554                 if (vstart + sizeof (*entry) > endbuf)
9555                   break;
9556
9557                 entry = (Elf_External_Verneed *) vstart;
9558
9559                 ent.vn_version = BYTE_GET (entry->vn_version);
9560                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9561                 ent.vn_file    = BYTE_GET (entry->vn_file);
9562                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9563                 ent.vn_next    = BYTE_GET (entry->vn_next);
9564
9565                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9566
9567                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9568                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9569                 else
9570                   printf (_("  File: %lx"), ent.vn_file);
9571
9572                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9573
9574                 /* Check for overflow.  */
9575                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9576                   break;
9577                 vstart += ent.vn_aux;
9578
9579                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9580                   {
9581                     Elf_External_Vernaux * eaux;
9582                     Elf_Internal_Vernaux aux;
9583
9584                     if (vstart + sizeof (*eaux) > endbuf)
9585                       break;
9586                     eaux = (Elf_External_Vernaux *) vstart;
9587
9588                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9589                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9590                     aux.vna_other = BYTE_GET (eaux->vna_other);
9591                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9592                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9593
9594                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9595                       printf (_("  %#06x:   Name: %s"),
9596                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9597                     else
9598                       printf (_("  %#06x:   Name index: %lx"),
9599                               isum, aux.vna_name);
9600
9601                     printf (_("  Flags: %s  Version: %d\n"),
9602                             get_ver_flags (aux.vna_flags), aux.vna_other);
9603
9604                     /* Check for overflow.  */
9605                     if (aux.vna_next > (size_t) (endbuf - vstart)
9606                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9607                       {
9608                         warn (_("Invalid vna_next field of %lx\n"),
9609                               aux.vna_next);
9610                         j = ent.vn_cnt;
9611                         break;
9612                       }
9613                     isum   += aux.vna_next;
9614                     vstart += aux.vna_next;
9615                   }
9616
9617                 if (j < ent.vn_cnt)
9618                   warn (_("Missing Version Needs auxillary information\n"));
9619
9620                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9621                   {
9622                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9623                     cnt = section->sh_info;
9624                     break;
9625                   }
9626                 idx += ent.vn_next;
9627               }
9628
9629             if (cnt < section->sh_info)
9630               warn (_("Missing Version Needs information\n"));
9631
9632             free (eneed);
9633           }
9634           break;
9635
9636         case SHT_GNU_versym:
9637           {
9638             Elf_Internal_Shdr * link_section;
9639             size_t total;
9640             unsigned int cnt;
9641             unsigned char * edata;
9642             unsigned short * data;
9643             char * strtab;
9644             Elf_Internal_Sym * symbols;
9645             Elf_Internal_Shdr * string_sec;
9646             unsigned long num_syms;
9647             long off;
9648
9649             if (section->sh_link >= elf_header.e_shnum)
9650               break;
9651
9652             link_section = section_headers + section->sh_link;
9653             total = section->sh_size / sizeof (Elf_External_Versym);
9654
9655             if (link_section->sh_link >= elf_header.e_shnum)
9656               break;
9657
9658             found = 1;
9659
9660             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9661             if (symbols == NULL)
9662               break;
9663
9664             string_sec = section_headers + link_section->sh_link;
9665
9666             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9667                                         string_sec->sh_size,
9668                                         _("version string table"));
9669             if (!strtab)
9670               {
9671                 free (symbols);
9672                 break;
9673               }
9674
9675             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9676                     printable_section_name (section), (unsigned long) total);
9677
9678             printf (_(" Addr: "));
9679             printf_vma (section->sh_addr);
9680             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9681                     (unsigned long) section->sh_offset, section->sh_link,
9682                     printable_section_name (link_section));
9683
9684             off = offset_from_vma (file,
9685                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9686                                    total * sizeof (short));
9687             edata = (unsigned char *) get_data (NULL, file, off, total,
9688                                                 sizeof (short),
9689                                                 _("version symbol data"));
9690             if (!edata)
9691               {
9692                 free (strtab);
9693                 free (symbols);
9694                 break;
9695               }
9696
9697             data = (short unsigned int *) cmalloc (total, sizeof (short));
9698
9699             for (cnt = total; cnt --;)
9700               data[cnt] = byte_get (edata + cnt * sizeof (short),
9701                                     sizeof (short));
9702
9703             free (edata);
9704
9705             for (cnt = 0; cnt < total; cnt += 4)
9706               {
9707                 int j, nn;
9708                 int check_def, check_need;
9709                 char * name;
9710
9711                 printf ("  %03x:", cnt);
9712
9713                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9714                   switch (data[cnt + j])
9715                     {
9716                     case 0:
9717                       fputs (_("   0 (*local*)    "), stdout);
9718                       break;
9719
9720                     case 1:
9721                       fputs (_("   1 (*global*)   "), stdout);
9722                       break;
9723
9724                     default:
9725                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9726                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9727
9728                       /* If this index value is greater than the size of the symbols
9729                          array, break to avoid an out-of-bounds read.  */
9730                       if ((unsigned long)(cnt + j) >= num_syms)
9731                         {
9732                           warn (_("invalid index into symbol array\n"));
9733                           break;
9734                         }
9735
9736                       check_def = 1;
9737                       check_need = 1;
9738                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9739                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9740                              != SHT_NOBITS)
9741                         {
9742                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9743                             check_def = 0;
9744                           else
9745                             check_need = 0;
9746                         }
9747
9748                       if (check_need
9749                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9750                         {
9751                           Elf_Internal_Verneed ivn;
9752                           unsigned long offset;
9753
9754                           offset = offset_from_vma
9755                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9756                              sizeof (Elf_External_Verneed));
9757
9758                           do
9759                             {
9760                               Elf_Internal_Vernaux ivna;
9761                               Elf_External_Verneed evn;
9762                               Elf_External_Vernaux evna;
9763                               unsigned long a_off;
9764
9765                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9766                                             _("version need")) == NULL)
9767                                 break;
9768
9769                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9770                               ivn.vn_next = BYTE_GET (evn.vn_next);
9771
9772                               a_off = offset + ivn.vn_aux;
9773
9774                               do
9775                                 {
9776                                   if (get_data (&evna, file, a_off, sizeof (evna),
9777                                                 1, _("version need aux (2)")) == NULL)
9778                                     {
9779                                       ivna.vna_next  = 0;
9780                                       ivna.vna_other = 0;
9781                                     }
9782                                   else
9783                                     {
9784                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9785                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9786                                     }
9787
9788                                   a_off += ivna.vna_next;
9789                                 }
9790                               while (ivna.vna_other != data[cnt + j]
9791                                      && ivna.vna_next != 0);
9792
9793                               if (ivna.vna_other == data[cnt + j])
9794                                 {
9795                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9796
9797                                   if (ivna.vna_name >= string_sec->sh_size)
9798                                     name = _("*invalid*");
9799                                   else
9800                                     name = strtab + ivna.vna_name;
9801                                   nn += printf ("(%s%-*s",
9802                                                 name,
9803                                                 12 - (int) strlen (name),
9804                                                 ")");
9805                                   check_def = 0;
9806                                   break;
9807                                 }
9808
9809                               offset += ivn.vn_next;
9810                             }
9811                           while (ivn.vn_next);
9812                         }
9813
9814                       if (check_def && data[cnt + j] != 0x8001
9815                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9816                         {
9817                           Elf_Internal_Verdef ivd;
9818                           Elf_External_Verdef evd;
9819                           unsigned long offset;
9820
9821                           offset = offset_from_vma
9822                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9823                              sizeof evd);
9824
9825                           do
9826                             {
9827                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9828                                             _("version def")) == NULL)
9829                                 {
9830                                   ivd.vd_next = 0;
9831                                   /* PR 17531: file: 046-1082287-0.004.  */
9832                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9833                                   break;
9834                                 }
9835                               else
9836                                 {
9837                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9838                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9839                                 }
9840
9841                               offset += ivd.vd_next;
9842                             }
9843                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9844                                  && ivd.vd_next != 0);
9845
9846                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9847                             {
9848                               Elf_External_Verdaux evda;
9849                               Elf_Internal_Verdaux ivda;
9850
9851                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9852
9853                               if (get_data (&evda, file,
9854                                             offset - ivd.vd_next + ivd.vd_aux,
9855                                             sizeof (evda), 1,
9856                                             _("version def aux")) == NULL)
9857                                 break;
9858
9859                               ivda.vda_name = BYTE_GET (evda.vda_name);
9860
9861                               if (ivda.vda_name >= string_sec->sh_size)
9862                                 name = _("*invalid*");
9863                               else
9864                                 name = strtab + ivda.vda_name;
9865                               nn += printf ("(%s%-*s",
9866                                             name,
9867                                             12 - (int) strlen (name),
9868                                             ")");
9869                             }
9870                         }
9871
9872                       if (nn < 18)
9873                         printf ("%*c", 18 - nn, ' ');
9874                     }
9875
9876                 putchar ('\n');
9877               }
9878
9879             free (data);
9880             free (strtab);
9881             free (symbols);
9882           }
9883           break;
9884
9885         default:
9886           break;
9887         }
9888     }
9889
9890   if (! found)
9891     printf (_("\nNo version information found in this file.\n"));
9892
9893   return 1;
9894 }
9895
9896 static const char *
9897 get_symbol_binding (unsigned int binding)
9898 {
9899   static char buff[32];
9900
9901   switch (binding)
9902     {
9903     case STB_LOCAL:     return "LOCAL";
9904     case STB_GLOBAL:    return "GLOBAL";
9905     case STB_WEAK:      return "WEAK";
9906     default:
9907       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9908         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9909                   binding);
9910       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9911         {
9912           if (binding == STB_GNU_UNIQUE
9913               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9914                   /* GNU is still using the default value 0.  */
9915                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9916             return "UNIQUE";
9917           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9918         }
9919       else
9920         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9921       return buff;
9922     }
9923 }
9924
9925 static const char *
9926 get_symbol_type (unsigned int type)
9927 {
9928   static char buff[32];
9929
9930   switch (type)
9931     {
9932     case STT_NOTYPE:    return "NOTYPE";
9933     case STT_OBJECT:    return "OBJECT";
9934     case STT_FUNC:      return "FUNC";
9935     case STT_SECTION:   return "SECTION";
9936     case STT_FILE:      return "FILE";
9937     case STT_COMMON:    return "COMMON";
9938     case STT_TLS:       return "TLS";
9939     case STT_RELC:      return "RELC";
9940     case STT_SRELC:     return "SRELC";
9941     default:
9942       if (type >= STT_LOPROC && type <= STT_HIPROC)
9943         {
9944           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9945             return "THUMB_FUNC";
9946
9947           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9948             return "REGISTER";
9949
9950           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9951             return "PARISC_MILLI";
9952
9953           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9954         }
9955       else if (type >= STT_LOOS && type <= STT_HIOS)
9956         {
9957           if (elf_header.e_machine == EM_PARISC)
9958             {
9959               if (type == STT_HP_OPAQUE)
9960                 return "HP_OPAQUE";
9961               if (type == STT_HP_STUB)
9962                 return "HP_STUB";
9963             }
9964
9965           if (type == STT_GNU_IFUNC
9966               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9967                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9968                   /* GNU is still using the default value 0.  */
9969                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9970             return "IFUNC";
9971
9972           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9973         }
9974       else
9975         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9976       return buff;
9977     }
9978 }
9979
9980 static const char *
9981 get_symbol_visibility (unsigned int visibility)
9982 {
9983   switch (visibility)
9984     {
9985     case STV_DEFAULT:   return "DEFAULT";
9986     case STV_INTERNAL:  return "INTERNAL";
9987     case STV_HIDDEN:    return "HIDDEN";
9988     case STV_PROTECTED: return "PROTECTED";
9989     default:
9990       error (_("Unrecognized visibility value: %u"), visibility);
9991       return _("<unknown>");
9992     }
9993 }
9994
9995 static const char *
9996 get_mips_symbol_other (unsigned int other)
9997 {
9998   switch (other)
9999     {
10000     case STO_OPTIONAL:
10001       return "OPTIONAL";
10002     case STO_MIPS_PLT:
10003       return "MIPS PLT";
10004     case STO_MIPS_PIC:
10005       return "MIPS PIC";
10006     case STO_MICROMIPS:
10007       return "MICROMIPS";
10008     case STO_MICROMIPS | STO_MIPS_PIC:
10009       return "MICROMIPS, MIPS PIC";
10010     case STO_MIPS16:
10011       return "MIPS16";
10012     default:
10013       return NULL;
10014     }
10015 }
10016
10017 static const char *
10018 get_ia64_symbol_other (unsigned int other)
10019 {
10020   if (is_ia64_vms ())
10021     {
10022       static char res[32];
10023
10024       res[0] = 0;
10025
10026       /* Function types is for images and .STB files only.  */
10027       switch (elf_header.e_type)
10028         {
10029         case ET_DYN:
10030         case ET_EXEC:
10031           switch (VMS_ST_FUNC_TYPE (other))
10032             {
10033             case VMS_SFT_CODE_ADDR:
10034               strcat (res, " CA");
10035               break;
10036             case VMS_SFT_SYMV_IDX:
10037               strcat (res, " VEC");
10038               break;
10039             case VMS_SFT_FD:
10040               strcat (res, " FD");
10041               break;
10042             case VMS_SFT_RESERVE:
10043               strcat (res, " RSV");
10044               break;
10045             default:
10046               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10047                     VMS_ST_FUNC_TYPE (other));
10048               strcat (res, " <unknown>");
10049               break;
10050             }
10051           break;
10052         default:
10053           break;
10054         }
10055       switch (VMS_ST_LINKAGE (other))
10056         {
10057         case VMS_STL_IGNORE:
10058           strcat (res, " IGN");
10059           break;
10060         case VMS_STL_RESERVE:
10061           strcat (res, " RSV");
10062           break;
10063         case VMS_STL_STD:
10064           strcat (res, " STD");
10065           break;
10066         case VMS_STL_LNK:
10067           strcat (res, " LNK");
10068           break;
10069         default:
10070           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10071                 VMS_ST_LINKAGE (other));
10072           strcat (res, " <unknown>");
10073           break;
10074         }
10075
10076       if (res[0] != 0)
10077         return res + 1;
10078       else
10079         return res;
10080     }
10081   return NULL;
10082 }
10083
10084 static const char *
10085 get_ppc64_symbol_other (unsigned int other)
10086 {
10087   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10088     {
10089       static char buf[32];
10090       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10091                 PPC64_LOCAL_ENTRY_OFFSET (other));
10092       return buf;
10093     }
10094   return NULL;
10095 }
10096
10097 static const char *
10098 get_symbol_other (unsigned int other)
10099 {
10100   const char * result = NULL;
10101   static char buff [32];
10102
10103   if (other == 0)
10104     return "";
10105
10106   switch (elf_header.e_machine)
10107     {
10108     case EM_MIPS:
10109       result = get_mips_symbol_other (other);
10110       break;
10111     case EM_IA_64:
10112       result = get_ia64_symbol_other (other);
10113       break;
10114     case EM_PPC64:
10115       result = get_ppc64_symbol_other (other);
10116       break;
10117     default:
10118       break;
10119     }
10120
10121   if (result)
10122     return result;
10123
10124   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10125   return buff;
10126 }
10127
10128 static const char *
10129 get_symbol_index_type (unsigned int type)
10130 {
10131   static char buff[32];
10132
10133   switch (type)
10134     {
10135     case SHN_UNDEF:     return "UND";
10136     case SHN_ABS:       return "ABS";
10137     case SHN_COMMON:    return "COM";
10138     default:
10139       if (type == SHN_IA_64_ANSI_COMMON
10140           && elf_header.e_machine == EM_IA_64
10141           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10142         return "ANSI_COM";
10143       else if ((elf_header.e_machine == EM_X86_64
10144                 || elf_header.e_machine == EM_L1OM
10145                 || elf_header.e_machine == EM_K1OM)
10146                && type == SHN_X86_64_LCOMMON)
10147         return "LARGE_COM";
10148       else if ((type == SHN_MIPS_SCOMMON
10149                 && elf_header.e_machine == EM_MIPS)
10150                || (type == SHN_TIC6X_SCOMMON
10151                    && elf_header.e_machine == EM_TI_C6000))
10152         return "SCOM";
10153       else if (type == SHN_MIPS_SUNDEFINED
10154                && elf_header.e_machine == EM_MIPS)
10155         return "SUND";
10156       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10157         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10158       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10159         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10160       else if (type >= SHN_LORESERVE)
10161         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10162       else if (type >= elf_header.e_shnum)
10163         sprintf (buff, _("bad section index[%3d]"), type);
10164       else
10165         sprintf (buff, "%3d", type);
10166       break;
10167     }
10168
10169   return buff;
10170 }
10171
10172 static bfd_vma *
10173 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10174 {
10175   unsigned char * e_data;
10176   bfd_vma * i_data;
10177
10178   /* If the size_t type is smaller than the bfd_size_type, eg because
10179      you are building a 32-bit tool on a 64-bit host, then make sure
10180      that when (number) is cast to (size_t) no information is lost.  */
10181   if (sizeof (size_t) < sizeof (bfd_size_type)
10182       && (bfd_size_type) ((size_t) number) != number)
10183     {
10184       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10185              (unsigned long long) number, ent_size);
10186       return NULL;
10187     }
10188
10189   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10190      attempting to allocate memory when the read is bound to fail.  */
10191   if (ent_size * number > current_file_size)
10192     {
10193       error (_("Invalid number of dynamic entries: %llu\n"),
10194              (unsigned long long) number);
10195       return NULL;
10196     }
10197
10198   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10199   if (e_data == NULL)
10200     {
10201       error (_("Out of memory reading %llu dynamic entries\n"),
10202              (unsigned long long) number);
10203       return NULL;
10204     }
10205
10206   if (fread (e_data, ent_size, (size_t) number, file) != number)
10207     {
10208       error (_("Unable to read in %llu bytes of dynamic data\n"),
10209              (unsigned long long) (number * ent_size));
10210       free (e_data);
10211       return NULL;
10212     }
10213
10214   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10215   if (i_data == NULL)
10216     {
10217       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10218              (unsigned long long) number);
10219       free (e_data);
10220       return NULL;
10221     }
10222
10223   while (number--)
10224     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10225
10226   free (e_data);
10227
10228   return i_data;
10229 }
10230
10231 static void
10232 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10233 {
10234   Elf_Internal_Sym * psym;
10235   int n;
10236
10237   n = print_vma (si, DEC_5);
10238   if (n < 5)
10239     fputs (&"     "[n], stdout);
10240   printf (" %3lu: ", hn);
10241
10242   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10243     {
10244       printf (_("<No info available for dynamic symbol number %lu>\n"),
10245               (unsigned long) si);
10246       return;
10247     }
10248
10249   psym = dynamic_symbols + si;
10250   print_vma (psym->st_value, LONG_HEX);
10251   putchar (' ');
10252   print_vma (psym->st_size, DEC_5);
10253
10254   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10255   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10256   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10257   /* Check to see if any other bits in the st_other field are set.
10258      Note - displaying this information disrupts the layout of the
10259      table being generated, but for the moment this case is very
10260      rare.  */
10261   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10262     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10263   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10264   if (VALID_DYNAMIC_NAME (psym->st_name))
10265     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10266   else
10267     printf (_(" <corrupt: %14ld>"), psym->st_name);
10268   putchar ('\n');
10269 }
10270
10271 static const char *
10272 get_symbol_version_string (FILE *file, int is_dynsym,
10273                            const char *strtab,
10274                            unsigned long int strtab_size,
10275                            unsigned int si, Elf_Internal_Sym *psym,
10276                            enum versioned_symbol_info *sym_info,
10277                            unsigned short *vna_other)
10278 {
10279   const char *version_string = NULL;
10280
10281   if (is_dynsym
10282       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10283     {
10284       unsigned char data[2];
10285       unsigned short vers_data;
10286       unsigned long offset;
10287       int is_nobits;
10288       int check_def;
10289
10290       offset = offset_from_vma
10291         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10292          sizeof data + si * sizeof (vers_data));
10293
10294       if (get_data (&data, file, offset + si * sizeof (vers_data),
10295                     sizeof (data), 1, _("version data")) == NULL)
10296         return NULL;
10297
10298       vers_data = byte_get (data, 2);
10299
10300       is_nobits = (section_headers != NULL
10301                    && psym->st_shndx < elf_header.e_shnum
10302                    && section_headers[psym->st_shndx].sh_type
10303                    == SHT_NOBITS);
10304
10305       check_def = (psym->st_shndx != SHN_UNDEF);
10306
10307       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10308         {
10309           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10310               && (is_nobits || ! check_def))
10311             {
10312               Elf_External_Verneed evn;
10313               Elf_Internal_Verneed ivn;
10314               Elf_Internal_Vernaux ivna;
10315
10316               /* We must test both.  */
10317               offset = offset_from_vma
10318                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10319                  sizeof evn);
10320
10321               do
10322                 {
10323                   unsigned long vna_off;
10324
10325                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10326                                 _("version need")) == NULL)
10327                     {
10328                       ivna.vna_next = 0;
10329                       ivna.vna_other = 0;
10330                       ivna.vna_name = 0;
10331                       break;
10332                     }
10333
10334                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10335                   ivn.vn_next = BYTE_GET (evn.vn_next);
10336
10337                   vna_off = offset + ivn.vn_aux;
10338
10339                   do
10340                     {
10341                       Elf_External_Vernaux evna;
10342
10343                       if (get_data (&evna, file, vna_off,
10344                                     sizeof (evna), 1,
10345                                     _("version need aux (3)")) == NULL)
10346                         {
10347                           ivna.vna_next = 0;
10348                           ivna.vna_other = 0;
10349                           ivna.vna_name = 0;
10350                         }
10351                       else
10352                         {
10353                           ivna.vna_other = BYTE_GET (evna.vna_other);
10354                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10355                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10356                         }
10357
10358                       vna_off += ivna.vna_next;
10359                     }
10360                   while (ivna.vna_other != vers_data
10361                          && ivna.vna_next != 0);
10362
10363                   if (ivna.vna_other == vers_data)
10364                     break;
10365
10366                   offset += ivn.vn_next;
10367                 }
10368               while (ivn.vn_next != 0);
10369
10370               if (ivna.vna_other == vers_data)
10371                 {
10372                   *sym_info = symbol_undefined;
10373                   *vna_other = ivna.vna_other;
10374                   version_string = (ivna.vna_name < strtab_size
10375                                     ? strtab + ivna.vna_name
10376                                     : _("<corrupt>"));
10377                   check_def = 0;
10378                 }
10379               else if (! is_nobits)
10380                 error (_("bad dynamic symbol\n"));
10381               else
10382                 check_def = 1;
10383             }
10384
10385           if (check_def)
10386             {
10387               if (vers_data != 0x8001
10388                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10389                 {
10390                   Elf_Internal_Verdef ivd;
10391                   Elf_Internal_Verdaux ivda;
10392                   Elf_External_Verdaux evda;
10393                   unsigned long off;
10394
10395                   off = offset_from_vma
10396                     (file,
10397                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10398                      sizeof (Elf_External_Verdef));
10399
10400                   do
10401                     {
10402                       Elf_External_Verdef evd;
10403
10404                       if (get_data (&evd, file, off, sizeof (evd),
10405                                     1, _("version def")) == NULL)
10406                         {
10407                           ivd.vd_ndx = 0;
10408                           ivd.vd_aux = 0;
10409                           ivd.vd_next = 0;
10410                         }
10411                       else
10412                         {
10413                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10414                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10415                           ivd.vd_next = BYTE_GET (evd.vd_next);
10416                         }
10417
10418                       off += ivd.vd_next;
10419                     }
10420                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10421                          && ivd.vd_next != 0);
10422
10423                   off -= ivd.vd_next;
10424                   off += ivd.vd_aux;
10425
10426                   if (get_data (&evda, file, off, sizeof (evda),
10427                                 1, _("version def aux")) == NULL)
10428                     return version_string;
10429
10430                   ivda.vda_name = BYTE_GET (evda.vda_name);
10431
10432                   if (psym->st_name != ivda.vda_name)
10433                     {
10434                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10435                                    ? symbol_hidden : symbol_public);
10436                       version_string = (ivda.vda_name < strtab_size
10437                                         ? strtab + ivda.vda_name
10438                                         : _("<corrupt>"));
10439                     }
10440                 }
10441             }
10442         }
10443     }
10444   return version_string;
10445 }
10446
10447 /* Dump the symbol table.  */
10448 static int
10449 process_symbol_table (FILE * file)
10450 {
10451   Elf_Internal_Shdr * section;
10452   bfd_size_type nbuckets = 0;
10453   bfd_size_type nchains = 0;
10454   bfd_vma * buckets = NULL;
10455   bfd_vma * chains = NULL;
10456   bfd_vma ngnubuckets = 0;
10457   bfd_vma * gnubuckets = NULL;
10458   bfd_vma * gnuchains = NULL;
10459   bfd_vma gnusymidx = 0;
10460   bfd_size_type ngnuchains = 0;
10461
10462   if (!do_syms && !do_dyn_syms && !do_histogram)
10463     return 1;
10464
10465   if (dynamic_info[DT_HASH]
10466       && (do_histogram
10467           || (do_using_dynamic
10468               && !do_dyn_syms
10469               && dynamic_strings != NULL)))
10470     {
10471       unsigned char nb[8];
10472       unsigned char nc[8];
10473       unsigned int hash_ent_size = 4;
10474
10475       if ((elf_header.e_machine == EM_ALPHA
10476            || elf_header.e_machine == EM_S390
10477            || elf_header.e_machine == EM_S390_OLD)
10478           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10479         hash_ent_size = 8;
10480
10481       if (fseek (file,
10482                  (archive_file_offset
10483                   + offset_from_vma (file, dynamic_info[DT_HASH],
10484                                      sizeof nb + sizeof nc)),
10485                  SEEK_SET))
10486         {
10487           error (_("Unable to seek to start of dynamic information\n"));
10488           goto no_hash;
10489         }
10490
10491       if (fread (nb, hash_ent_size, 1, file) != 1)
10492         {
10493           error (_("Failed to read in number of buckets\n"));
10494           goto no_hash;
10495         }
10496
10497       if (fread (nc, hash_ent_size, 1, file) != 1)
10498         {
10499           error (_("Failed to read in number of chains\n"));
10500           goto no_hash;
10501         }
10502
10503       nbuckets = byte_get (nb, hash_ent_size);
10504       nchains  = byte_get (nc, hash_ent_size);
10505
10506       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10507       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10508
10509     no_hash:
10510       if (buckets == NULL || chains == NULL)
10511         {
10512           if (do_using_dynamic)
10513             return 0;
10514           free (buckets);
10515           free (chains);
10516           buckets = NULL;
10517           chains = NULL;
10518           nbuckets = 0;
10519           nchains = 0;
10520         }
10521     }
10522
10523   if (dynamic_info_DT_GNU_HASH
10524       && (do_histogram
10525           || (do_using_dynamic
10526               && !do_dyn_syms
10527               && dynamic_strings != NULL)))
10528     {
10529       unsigned char nb[16];
10530       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10531       bfd_vma buckets_vma;
10532
10533       if (fseek (file,
10534                  (archive_file_offset
10535                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10536                                      sizeof nb)),
10537                  SEEK_SET))
10538         {
10539           error (_("Unable to seek to start of dynamic information\n"));
10540           goto no_gnu_hash;
10541         }
10542
10543       if (fread (nb, 16, 1, file) != 1)
10544         {
10545           error (_("Failed to read in number of buckets\n"));
10546           goto no_gnu_hash;
10547         }
10548
10549       ngnubuckets = byte_get (nb, 4);
10550       gnusymidx = byte_get (nb + 4, 4);
10551       bitmaskwords = byte_get (nb + 8, 4);
10552       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10553       if (is_32bit_elf)
10554         buckets_vma += bitmaskwords * 4;
10555       else
10556         buckets_vma += bitmaskwords * 8;
10557
10558       if (fseek (file,
10559                  (archive_file_offset
10560                   + offset_from_vma (file, buckets_vma, 4)),
10561                  SEEK_SET))
10562         {
10563           error (_("Unable to seek to start of dynamic information\n"));
10564           goto no_gnu_hash;
10565         }
10566
10567       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10568
10569       if (gnubuckets == NULL)
10570         goto no_gnu_hash;
10571
10572       for (i = 0; i < ngnubuckets; i++)
10573         if (gnubuckets[i] != 0)
10574           {
10575             if (gnubuckets[i] < gnusymidx)
10576               return 0;
10577
10578             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10579               maxchain = gnubuckets[i];
10580           }
10581
10582       if (maxchain == 0xffffffff)
10583         goto no_gnu_hash;
10584
10585       maxchain -= gnusymidx;
10586
10587       if (fseek (file,
10588                  (archive_file_offset
10589                   + offset_from_vma (file, buckets_vma
10590                                            + 4 * (ngnubuckets + maxchain), 4)),
10591                  SEEK_SET))
10592         {
10593           error (_("Unable to seek to start of dynamic information\n"));
10594           goto no_gnu_hash;
10595         }
10596
10597       do
10598         {
10599           if (fread (nb, 4, 1, file) != 1)
10600             {
10601               error (_("Failed to determine last chain length\n"));
10602               goto no_gnu_hash;
10603             }
10604
10605           if (maxchain + 1 == 0)
10606             goto no_gnu_hash;
10607
10608           ++maxchain;
10609         }
10610       while ((byte_get (nb, 4) & 1) == 0);
10611
10612       if (fseek (file,
10613                  (archive_file_offset
10614                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10615                  SEEK_SET))
10616         {
10617           error (_("Unable to seek to start of dynamic information\n"));
10618           goto no_gnu_hash;
10619         }
10620
10621       gnuchains = get_dynamic_data (file, maxchain, 4);
10622       ngnuchains = maxchain;
10623
10624     no_gnu_hash:
10625       if (gnuchains == NULL)
10626         {
10627           free (gnubuckets);
10628           gnubuckets = NULL;
10629           ngnubuckets = 0;
10630           if (do_using_dynamic)
10631             return 0;
10632         }
10633     }
10634
10635   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10636       && do_syms
10637       && do_using_dynamic
10638       && dynamic_strings != NULL
10639       && dynamic_symbols != NULL)
10640     {
10641       unsigned long hn;
10642
10643       if (dynamic_info[DT_HASH])
10644         {
10645           bfd_vma si;
10646
10647           printf (_("\nSymbol table for image:\n"));
10648           if (is_32bit_elf)
10649             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10650           else
10651             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10652
10653           for (hn = 0; hn < nbuckets; hn++)
10654             {
10655               if (! buckets[hn])
10656                 continue;
10657
10658               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10659                 print_dynamic_symbol (si, hn);
10660             }
10661         }
10662
10663       if (dynamic_info_DT_GNU_HASH)
10664         {
10665           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10666           if (is_32bit_elf)
10667             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10668           else
10669             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10670
10671           for (hn = 0; hn < ngnubuckets; ++hn)
10672             if (gnubuckets[hn] != 0)
10673               {
10674                 bfd_vma si = gnubuckets[hn];
10675                 bfd_vma off = si - gnusymidx;
10676
10677                 do
10678                   {
10679                     print_dynamic_symbol (si, hn);
10680                     si++;
10681                   }
10682                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10683               }
10684         }
10685     }
10686   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10687            && section_headers != NULL)
10688     {
10689       unsigned int i;
10690
10691       for (i = 0, section = section_headers;
10692            i < elf_header.e_shnum;
10693            i++, section++)
10694         {
10695           unsigned int si;
10696           char * strtab = NULL;
10697           unsigned long int strtab_size = 0;
10698           Elf_Internal_Sym * symtab;
10699           Elf_Internal_Sym * psym;
10700           unsigned long num_syms;
10701
10702           if ((section->sh_type != SHT_SYMTAB
10703                && section->sh_type != SHT_DYNSYM)
10704               || (!do_syms
10705                   && section->sh_type == SHT_SYMTAB))
10706             continue;
10707
10708           if (section->sh_entsize == 0)
10709             {
10710               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10711                       printable_section_name (section));
10712               continue;
10713             }
10714
10715           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10716                   printable_section_name (section),
10717                   (unsigned long) (section->sh_size / section->sh_entsize));
10718
10719           if (is_32bit_elf)
10720             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10721           else
10722             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10723
10724           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10725           if (symtab == NULL)
10726             continue;
10727
10728           if (section->sh_link == elf_header.e_shstrndx)
10729             {
10730               strtab = string_table;
10731               strtab_size = string_table_length;
10732             }
10733           else if (section->sh_link < elf_header.e_shnum)
10734             {
10735               Elf_Internal_Shdr * string_sec;
10736
10737               string_sec = section_headers + section->sh_link;
10738
10739               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10740                                           1, string_sec->sh_size,
10741                                           _("string table"));
10742               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10743             }
10744
10745           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10746             {
10747               const char *version_string;
10748               enum versioned_symbol_info sym_info;
10749               unsigned short vna_other;
10750
10751               printf ("%6d: ", si);
10752               print_vma (psym->st_value, LONG_HEX);
10753               putchar (' ');
10754               print_vma (psym->st_size, DEC_5);
10755               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10756               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10757               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10758               /* Check to see if any other bits in the st_other field are set.
10759                  Note - displaying this information disrupts the layout of the
10760                  table being generated, but for the moment this case is very rare.  */
10761               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10762                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10763               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10764               print_symbol (25, psym->st_name < strtab_size
10765                             ? strtab + psym->st_name : _("<corrupt>"));
10766
10767               version_string
10768                 = get_symbol_version_string (file,
10769                                              section->sh_type == SHT_DYNSYM,
10770                                              strtab, strtab_size, si,
10771                                              psym, &sym_info, &vna_other);
10772               if (version_string)
10773                 {
10774                   if (sym_info == symbol_undefined)
10775                     printf ("@%s (%d)", version_string, vna_other);
10776                   else
10777                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10778                             version_string);
10779                 }
10780
10781               putchar ('\n');
10782             }
10783
10784           free (symtab);
10785           if (strtab != string_table)
10786             free (strtab);
10787         }
10788     }
10789   else if (do_syms)
10790     printf
10791       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10792
10793   if (do_histogram && buckets != NULL)
10794     {
10795       unsigned long * lengths;
10796       unsigned long * counts;
10797       unsigned long hn;
10798       bfd_vma si;
10799       unsigned long maxlength = 0;
10800       unsigned long nzero_counts = 0;
10801       unsigned long nsyms = 0;
10802       unsigned long chained;
10803
10804       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10805               (unsigned long) nbuckets);
10806
10807       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10808       if (lengths == NULL)
10809         {
10810           error (_("Out of memory allocating space for histogram buckets\n"));
10811           return 0;
10812         }
10813
10814       printf (_(" Length  Number     %% of total  Coverage\n"));
10815       for (hn = 0; hn < nbuckets; ++hn)
10816         {
10817           for (si = buckets[hn], chained = 0;
10818                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10819                si = chains[si], ++chained)
10820             {
10821               ++nsyms;
10822               if (maxlength < ++lengths[hn])
10823                 ++maxlength;
10824             }
10825
10826             /* PR binutils/17531: A corrupt binary could contain broken
10827                histogram data.  Do not go into an infinite loop trying
10828                to process it.  */
10829             if (chained > nchains)
10830               {
10831                 error (_("histogram chain is corrupt\n"));
10832                 break;
10833               }
10834         }
10835
10836       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10837       if (counts == NULL)
10838         {
10839           free (lengths);
10840           error (_("Out of memory allocating space for histogram counts\n"));
10841           return 0;
10842         }
10843
10844       for (hn = 0; hn < nbuckets; ++hn)
10845         ++counts[lengths[hn]];
10846
10847       if (nbuckets > 0)
10848         {
10849           unsigned long i;
10850           printf ("      0  %-10lu (%5.1f%%)\n",
10851                   counts[0], (counts[0] * 100.0) / nbuckets);
10852           for (i = 1; i <= maxlength; ++i)
10853             {
10854               nzero_counts += counts[i] * i;
10855               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10856                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10857                       (nzero_counts * 100.0) / nsyms);
10858             }
10859         }
10860
10861       free (counts);
10862       free (lengths);
10863     }
10864
10865   if (buckets != NULL)
10866     {
10867       free (buckets);
10868       free (chains);
10869     }
10870
10871   if (do_histogram && gnubuckets != NULL)
10872     {
10873       unsigned long * lengths;
10874       unsigned long * counts;
10875       unsigned long hn;
10876       unsigned long maxlength = 0;
10877       unsigned long nzero_counts = 0;
10878       unsigned long nsyms = 0;
10879
10880       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10881               (unsigned long) ngnubuckets);
10882
10883       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10884       if (lengths == NULL)
10885         {
10886           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10887           return 0;
10888         }
10889
10890       printf (_(" Length  Number     %% of total  Coverage\n"));
10891
10892       for (hn = 0; hn < ngnubuckets; ++hn)
10893         if (gnubuckets[hn] != 0)
10894           {
10895             bfd_vma off, length = 1;
10896
10897             for (off = gnubuckets[hn] - gnusymidx;
10898                  /* PR 17531 file: 010-77222-0.004.  */
10899                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10900                  ++off)
10901               ++length;
10902             lengths[hn] = length;
10903             if (length > maxlength)
10904               maxlength = length;
10905             nsyms += length;
10906           }
10907
10908       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10909       if (counts == NULL)
10910         {
10911           free (lengths);
10912           error (_("Out of memory allocating space for gnu histogram counts\n"));
10913           return 0;
10914         }
10915
10916       for (hn = 0; hn < ngnubuckets; ++hn)
10917         ++counts[lengths[hn]];
10918
10919       if (ngnubuckets > 0)
10920         {
10921           unsigned long j;
10922           printf ("      0  %-10lu (%5.1f%%)\n",
10923                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10924           for (j = 1; j <= maxlength; ++j)
10925             {
10926               nzero_counts += counts[j] * j;
10927               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10928                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10929                       (nzero_counts * 100.0) / nsyms);
10930             }
10931         }
10932
10933       free (counts);
10934       free (lengths);
10935       free (gnubuckets);
10936       free (gnuchains);
10937     }
10938
10939   return 1;
10940 }
10941
10942 static int
10943 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10944 {
10945   unsigned int i;
10946
10947   if (dynamic_syminfo == NULL
10948       || !do_dynamic)
10949     /* No syminfo, this is ok.  */
10950     return 1;
10951
10952   /* There better should be a dynamic symbol section.  */
10953   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10954     return 0;
10955
10956   if (dynamic_addr)
10957     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10958             dynamic_syminfo_offset, dynamic_syminfo_nent);
10959
10960   printf (_(" Num: Name                           BoundTo     Flags\n"));
10961   for (i = 0; i < dynamic_syminfo_nent; ++i)
10962     {
10963       unsigned short int flags = dynamic_syminfo[i].si_flags;
10964
10965       printf ("%4d: ", i);
10966       if (i >= num_dynamic_syms)
10967         printf (_("<corrupt index>"));
10968       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10969         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10970       else
10971         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10972       putchar (' ');
10973
10974       switch (dynamic_syminfo[i].si_boundto)
10975         {
10976         case SYMINFO_BT_SELF:
10977           fputs ("SELF       ", stdout);
10978           break;
10979         case SYMINFO_BT_PARENT:
10980           fputs ("PARENT     ", stdout);
10981           break;
10982         default:
10983           if (dynamic_syminfo[i].si_boundto > 0
10984               && dynamic_syminfo[i].si_boundto < dynamic_nent
10985               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10986             {
10987               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10988               putchar (' ' );
10989             }
10990           else
10991             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10992           break;
10993         }
10994
10995       if (flags & SYMINFO_FLG_DIRECT)
10996         printf (" DIRECT");
10997       if (flags & SYMINFO_FLG_PASSTHRU)
10998         printf (" PASSTHRU");
10999       if (flags & SYMINFO_FLG_COPY)
11000         printf (" COPY");
11001       if (flags & SYMINFO_FLG_LAZYLOAD)
11002         printf (" LAZYLOAD");
11003
11004       puts ("");
11005     }
11006
11007   return 1;
11008 }
11009
11010 /* Check to see if the given reloc needs to be handled in a target specific
11011    manner.  If so then process the reloc and return TRUE otherwise return
11012    FALSE.  */
11013
11014 static bfd_boolean
11015 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11016                                 unsigned char *     start,
11017                                 Elf_Internal_Sym *  symtab)
11018 {
11019   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11020
11021   switch (elf_header.e_machine)
11022     {
11023     case EM_MSP430:
11024     case EM_MSP430_OLD:
11025       {
11026         static Elf_Internal_Sym * saved_sym = NULL;
11027
11028         switch (reloc_type)
11029           {
11030           case 10: /* R_MSP430_SYM_DIFF */
11031             if (uses_msp430x_relocs ())
11032               break;
11033           case 21: /* R_MSP430X_SYM_DIFF */
11034             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11035             return TRUE;
11036
11037           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11038           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11039             goto handle_sym_diff;
11040
11041           case 5: /* R_MSP430_16_BYTE */
11042           case 9: /* R_MSP430_8 */
11043             if (uses_msp430x_relocs ())
11044               break;
11045             goto handle_sym_diff;
11046
11047           case 2: /* R_MSP430_ABS16 */
11048           case 15: /* R_MSP430X_ABS16 */
11049             if (! uses_msp430x_relocs ())
11050               break;
11051             goto handle_sym_diff;
11052
11053           handle_sym_diff:
11054             if (saved_sym != NULL)
11055               {
11056                 bfd_vma value;
11057
11058                 value = reloc->r_addend
11059                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11060                      - saved_sym->st_value);
11061
11062                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11063
11064                 saved_sym = NULL;
11065                 return TRUE;
11066               }
11067             break;
11068
11069           default:
11070             if (saved_sym != NULL)
11071               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11072             break;
11073           }
11074         break;
11075       }
11076
11077     case EM_MN10300:
11078     case EM_CYGNUS_MN10300:
11079       {
11080         static Elf_Internal_Sym * saved_sym = NULL;
11081
11082         switch (reloc_type)
11083           {
11084           case 34: /* R_MN10300_ALIGN */
11085             return TRUE;
11086           case 33: /* R_MN10300_SYM_DIFF */
11087             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11088             return TRUE;
11089           case 1: /* R_MN10300_32 */
11090           case 2: /* R_MN10300_16 */
11091             if (saved_sym != NULL)
11092               {
11093                 bfd_vma value;
11094
11095                 value = reloc->r_addend
11096                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11097                      - saved_sym->st_value);
11098
11099                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11100
11101                 saved_sym = NULL;
11102                 return TRUE;
11103               }
11104             break;
11105           default:
11106             if (saved_sym != NULL)
11107               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11108             break;
11109           }
11110         break;
11111       }
11112     }
11113
11114   return FALSE;
11115 }
11116
11117 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11118    DWARF debug sections.  This is a target specific test.  Note - we do not
11119    go through the whole including-target-headers-multiple-times route, (as
11120    we have already done with <elf/h8.h>) because this would become very
11121    messy and even then this function would have to contain target specific
11122    information (the names of the relocs instead of their numeric values).
11123    FIXME: This is not the correct way to solve this problem.  The proper way
11124    is to have target specific reloc sizing and typing functions created by
11125    the reloc-macros.h header, in the same way that it already creates the
11126    reloc naming functions.  */
11127
11128 static bfd_boolean
11129 is_32bit_abs_reloc (unsigned int reloc_type)
11130 {
11131   switch (elf_header.e_machine)
11132     {
11133     case EM_386:
11134     case EM_486:
11135       return reloc_type == 1; /* R_386_32.  */
11136     case EM_68K:
11137       return reloc_type == 1; /* R_68K_32.  */
11138     case EM_860:
11139       return reloc_type == 1; /* R_860_32.  */
11140     case EM_960:
11141       return reloc_type == 2; /* R_960_32.  */
11142     case EM_AARCH64:
11143       return reloc_type == 258; /* R_AARCH64_ABS32 */
11144     case EM_ALPHA:
11145       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11146     case EM_ARC:
11147       return reloc_type == 1; /* R_ARC_32.  */
11148     case EM_ARM:
11149       return reloc_type == 2; /* R_ARM_ABS32 */
11150     case EM_AVR_OLD:
11151     case EM_AVR:
11152       return reloc_type == 1;
11153     case EM_ADAPTEVA_EPIPHANY:
11154       return reloc_type == 3;
11155     case EM_BLACKFIN:
11156       return reloc_type == 0x12; /* R_byte4_data.  */
11157     case EM_CRIS:
11158       return reloc_type == 3; /* R_CRIS_32.  */
11159     case EM_CR16:
11160       return reloc_type == 3; /* R_CR16_NUM32.  */
11161     case EM_CRX:
11162       return reloc_type == 15; /* R_CRX_NUM32.  */
11163     case EM_CYGNUS_FRV:
11164       return reloc_type == 1;
11165     case EM_CYGNUS_D10V:
11166     case EM_D10V:
11167       return reloc_type == 6; /* R_D10V_32.  */
11168     case EM_CYGNUS_D30V:
11169     case EM_D30V:
11170       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11171     case EM_DLX:
11172       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11173     case EM_CYGNUS_FR30:
11174     case EM_FR30:
11175       return reloc_type == 3; /* R_FR30_32.  */
11176     case EM_FT32:
11177       return reloc_type == 1; /* R_FT32_32.  */
11178     case EM_H8S:
11179     case EM_H8_300:
11180     case EM_H8_300H:
11181       return reloc_type == 1; /* R_H8_DIR32.  */
11182     case EM_IA_64:
11183       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
11184     case EM_IP2K_OLD:
11185     case EM_IP2K:
11186       return reloc_type == 2; /* R_IP2K_32.  */
11187     case EM_IQ2000:
11188       return reloc_type == 2; /* R_IQ2000_32.  */
11189     case EM_LATTICEMICO32:
11190       return reloc_type == 3; /* R_LM32_32.  */
11191     case EM_M32C_OLD:
11192     case EM_M32C:
11193       return reloc_type == 3; /* R_M32C_32.  */
11194     case EM_M32R:
11195       return reloc_type == 34; /* R_M32R_32_RELA.  */
11196     case EM_MCORE:
11197       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11198     case EM_CYGNUS_MEP:
11199       return reloc_type == 4; /* R_MEP_32.  */
11200     case EM_METAG:
11201       return reloc_type == 2; /* R_METAG_ADDR32.  */
11202     case EM_MICROBLAZE:
11203       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11204     case EM_MIPS:
11205       return reloc_type == 2; /* R_MIPS_32.  */
11206     case EM_MMIX:
11207       return reloc_type == 4; /* R_MMIX_32.  */
11208     case EM_CYGNUS_MN10200:
11209     case EM_MN10200:
11210       return reloc_type == 1; /* R_MN10200_32.  */
11211     case EM_CYGNUS_MN10300:
11212     case EM_MN10300:
11213       return reloc_type == 1; /* R_MN10300_32.  */
11214     case EM_MOXIE:
11215       return reloc_type == 1; /* R_MOXIE_32.  */
11216     case EM_MSP430_OLD:
11217     case EM_MSP430:
11218       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11219     case EM_MT:
11220       return reloc_type == 2; /* R_MT_32.  */
11221     case EM_NDS32:
11222       return reloc_type == 20; /* R_NDS32_RELA.  */
11223     case EM_ALTERA_NIOS2:
11224       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11225     case EM_NIOS32:
11226       return reloc_type == 1; /* R_NIOS_32.  */
11227     case EM_OR1K:
11228       return reloc_type == 1; /* R_OR1K_32.  */
11229     case EM_PARISC:
11230       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11231               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11232     case EM_PJ:
11233     case EM_PJ_OLD:
11234       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11235     case EM_PPC64:
11236       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11237     case EM_PPC:
11238       return reloc_type == 1; /* R_PPC_ADDR32.  */
11239     case EM_RL78:
11240       return reloc_type == 1; /* R_RL78_DIR32.  */
11241     case EM_RX:
11242       return reloc_type == 1; /* R_RX_DIR32.  */
11243     case EM_S370:
11244       return reloc_type == 1; /* R_I370_ADDR31.  */
11245     case EM_S390_OLD:
11246     case EM_S390:
11247       return reloc_type == 4; /* R_S390_32.  */
11248     case EM_SCORE:
11249       return reloc_type == 8; /* R_SCORE_ABS32.  */
11250     case EM_SH:
11251       return reloc_type == 1; /* R_SH_DIR32.  */
11252     case EM_SPARC32PLUS:
11253     case EM_SPARCV9:
11254     case EM_SPARC:
11255       return reloc_type == 3 /* R_SPARC_32.  */
11256         || reloc_type == 23; /* R_SPARC_UA32.  */
11257     case EM_SPU:
11258       return reloc_type == 6; /* R_SPU_ADDR32 */
11259     case EM_TI_C6000:
11260       return reloc_type == 1; /* R_C6000_ABS32.  */
11261     case EM_TILEGX:
11262       return reloc_type == 2; /* R_TILEGX_32.  */
11263     case EM_TILEPRO:
11264       return reloc_type == 1; /* R_TILEPRO_32.  */
11265     case EM_CYGNUS_V850:
11266     case EM_V850:
11267       return reloc_type == 6; /* R_V850_ABS32.  */
11268     case EM_V800:
11269       return reloc_type == 0x33; /* R_V810_WORD.  */
11270     case EM_VAX:
11271       return reloc_type == 1; /* R_VAX_32.  */
11272     case EM_VISIUM:
11273       return reloc_type == 3;  /* R_VISIUM_32. */
11274     case EM_X86_64:
11275     case EM_L1OM:
11276     case EM_K1OM:
11277       return reloc_type == 10; /* R_X86_64_32.  */
11278     case EM_XC16X:
11279     case EM_C166:
11280       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11281     case EM_XGATE:
11282       return reloc_type == 4; /* R_XGATE_32.  */
11283     case EM_XSTORMY16:
11284       return reloc_type == 1; /* R_XSTROMY16_32.  */
11285     case EM_XTENSA_OLD:
11286     case EM_XTENSA:
11287       return reloc_type == 1; /* R_XTENSA_32.  */
11288     default:
11289       {
11290         static unsigned int prev_warn = 0;
11291
11292         /* Avoid repeating the same warning multiple times.  */
11293         if (prev_warn != elf_header.e_machine)
11294           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11295                  elf_header.e_machine);
11296         prev_warn = elf_header.e_machine;
11297         return FALSE;
11298       }
11299     }
11300 }
11301
11302 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11303    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11304
11305 static bfd_boolean
11306 is_32bit_pcrel_reloc (unsigned int reloc_type)
11307 {
11308   switch (elf_header.e_machine)
11309     {
11310     case EM_386:
11311     case EM_486:
11312       return reloc_type == 2;  /* R_386_PC32.  */
11313     case EM_68K:
11314       return reloc_type == 4;  /* R_68K_PC32.  */
11315     case EM_AARCH64:
11316       return reloc_type == 261; /* R_AARCH64_PREL32 */
11317     case EM_ADAPTEVA_EPIPHANY:
11318       return reloc_type == 6;
11319     case EM_ALPHA:
11320       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11321     case EM_ARM:
11322       return reloc_type == 3;  /* R_ARM_REL32 */
11323     case EM_MICROBLAZE:
11324       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11325     case EM_OR1K:
11326       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11327     case EM_PARISC:
11328       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11329     case EM_PPC:
11330       return reloc_type == 26; /* R_PPC_REL32.  */
11331     case EM_PPC64:
11332       return reloc_type == 26; /* R_PPC64_REL32.  */
11333     case EM_S390_OLD:
11334     case EM_S390:
11335       return reloc_type == 5;  /* R_390_PC32.  */
11336     case EM_SH:
11337       return reloc_type == 2;  /* R_SH_REL32.  */
11338     case EM_SPARC32PLUS:
11339     case EM_SPARCV9:
11340     case EM_SPARC:
11341       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11342     case EM_SPU:
11343       return reloc_type == 13; /* R_SPU_REL32.  */
11344     case EM_TILEGX:
11345       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11346     case EM_TILEPRO:
11347       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11348     case EM_VISIUM:
11349       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11350     case EM_X86_64:
11351     case EM_L1OM:
11352     case EM_K1OM:
11353       return reloc_type == 2;  /* R_X86_64_PC32.  */
11354     case EM_XTENSA_OLD:
11355     case EM_XTENSA:
11356       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11357     default:
11358       /* Do not abort or issue an error message here.  Not all targets use
11359          pc-relative 32-bit relocs in their DWARF debug information and we
11360          have already tested for target coverage in is_32bit_abs_reloc.  A
11361          more helpful warning message will be generated by apply_relocations
11362          anyway, so just return.  */
11363       return FALSE;
11364     }
11365 }
11366
11367 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11368    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11369
11370 static bfd_boolean
11371 is_64bit_abs_reloc (unsigned int reloc_type)
11372 {
11373   switch (elf_header.e_machine)
11374     {
11375     case EM_AARCH64:
11376       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11377     case EM_ALPHA:
11378       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11379     case EM_IA_64:
11380       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11381     case EM_PARISC:
11382       return reloc_type == 80; /* R_PARISC_DIR64.  */
11383     case EM_PPC64:
11384       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11385     case EM_SPARC32PLUS:
11386     case EM_SPARCV9:
11387     case EM_SPARC:
11388       return reloc_type == 54; /* R_SPARC_UA64.  */
11389     case EM_X86_64:
11390     case EM_L1OM:
11391     case EM_K1OM:
11392       return reloc_type == 1; /* R_X86_64_64.  */
11393     case EM_S390_OLD:
11394     case EM_S390:
11395       return reloc_type == 22;  /* R_S390_64.  */
11396     case EM_TILEGX:
11397       return reloc_type == 1; /* R_TILEGX_64.  */
11398     case EM_MIPS:
11399       return reloc_type == 18;  /* R_MIPS_64.  */
11400     default:
11401       return FALSE;
11402     }
11403 }
11404
11405 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11406    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11407
11408 static bfd_boolean
11409 is_64bit_pcrel_reloc (unsigned int reloc_type)
11410 {
11411   switch (elf_header.e_machine)
11412     {
11413     case EM_AARCH64:
11414       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11415     case EM_ALPHA:
11416       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11417     case EM_IA_64:
11418       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11419     case EM_PARISC:
11420       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11421     case EM_PPC64:
11422       return reloc_type == 44; /* R_PPC64_REL64.  */
11423     case EM_SPARC32PLUS:
11424     case EM_SPARCV9:
11425     case EM_SPARC:
11426       return reloc_type == 46; /* R_SPARC_DISP64.  */
11427     case EM_X86_64:
11428     case EM_L1OM:
11429     case EM_K1OM:
11430       return reloc_type == 24; /* R_X86_64_PC64.  */
11431     case EM_S390_OLD:
11432     case EM_S390:
11433       return reloc_type == 23;  /* R_S390_PC64.  */
11434     case EM_TILEGX:
11435       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11436     default:
11437       return FALSE;
11438     }
11439 }
11440
11441 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11442    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11443
11444 static bfd_boolean
11445 is_24bit_abs_reloc (unsigned int reloc_type)
11446 {
11447   switch (elf_header.e_machine)
11448     {
11449     case EM_CYGNUS_MN10200:
11450     case EM_MN10200:
11451       return reloc_type == 4; /* R_MN10200_24.  */
11452     default:
11453       return FALSE;
11454     }
11455 }
11456
11457 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11458    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11459
11460 static bfd_boolean
11461 is_16bit_abs_reloc (unsigned int reloc_type)
11462 {
11463   switch (elf_header.e_machine)
11464     {
11465     case EM_AVR_OLD:
11466     case EM_AVR:
11467       return reloc_type == 4; /* R_AVR_16.  */
11468     case EM_ADAPTEVA_EPIPHANY:
11469       return reloc_type == 5;
11470     case EM_CYGNUS_D10V:
11471     case EM_D10V:
11472       return reloc_type == 3; /* R_D10V_16.  */
11473     case EM_H8S:
11474     case EM_H8_300:
11475     case EM_H8_300H:
11476       return reloc_type == R_H8_DIR16;
11477     case EM_IP2K_OLD:
11478     case EM_IP2K:
11479       return reloc_type == 1; /* R_IP2K_16.  */
11480     case EM_M32C_OLD:
11481     case EM_M32C:
11482       return reloc_type == 1; /* R_M32C_16 */
11483     case EM_MSP430:
11484       if (uses_msp430x_relocs ())
11485         return reloc_type == 2; /* R_MSP430_ABS16.  */
11486     case EM_MSP430_OLD:
11487       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11488     case EM_NDS32:
11489       return reloc_type == 19; /* R_NDS32_RELA.  */
11490     case EM_ALTERA_NIOS2:
11491       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11492     case EM_NIOS32:
11493       return reloc_type == 9; /* R_NIOS_16.  */
11494     case EM_OR1K:
11495       return reloc_type == 2; /* R_OR1K_16.  */
11496     case EM_TI_C6000:
11497       return reloc_type == 2; /* R_C6000_ABS16.  */
11498     case EM_XC16X:
11499     case EM_C166:
11500       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11501     case EM_CYGNUS_MN10200:
11502     case EM_MN10200:
11503       return reloc_type == 2; /* R_MN10200_16.  */
11504     case EM_CYGNUS_MN10300:
11505     case EM_MN10300:
11506       return reloc_type == 2; /* R_MN10300_16.  */
11507     case EM_VISIUM:
11508       return reloc_type == 2; /* R_VISIUM_16. */
11509     case EM_XGATE:
11510       return reloc_type == 3; /* R_XGATE_16.  */
11511     default:
11512       return FALSE;
11513     }
11514 }
11515
11516 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11517    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11518
11519 static bfd_boolean
11520 is_none_reloc (unsigned int reloc_type)
11521 {
11522   switch (elf_header.e_machine)
11523     {
11524     case EM_68K:     /* R_68K_NONE.  */
11525     case EM_386:     /* R_386_NONE.  */
11526     case EM_SPARC32PLUS:
11527     case EM_SPARCV9:
11528     case EM_SPARC:   /* R_SPARC_NONE.  */
11529     case EM_MIPS:    /* R_MIPS_NONE.  */
11530     case EM_PARISC:  /* R_PARISC_NONE.  */
11531     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11532     case EM_ADAPTEVA_EPIPHANY:
11533     case EM_PPC:     /* R_PPC_NONE.  */
11534     case EM_PPC64:   /* R_PPC64_NONE.  */
11535     case EM_ARM:     /* R_ARM_NONE.  */
11536     case EM_IA_64:   /* R_IA64_NONE.  */
11537     case EM_SH:      /* R_SH_NONE.  */
11538     case EM_S390_OLD:
11539     case EM_S390:    /* R_390_NONE.  */
11540     case EM_CRIS:    /* R_CRIS_NONE.  */
11541     case EM_X86_64:  /* R_X86_64_NONE.  */
11542     case EM_L1OM:    /* R_X86_64_NONE.  */
11543     case EM_K1OM:    /* R_X86_64_NONE.  */
11544     case EM_MN10300: /* R_MN10300_NONE.  */
11545     case EM_FT32:    /* R_FT32_NONE.  */
11546     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11547     case EM_M32R:    /* R_M32R_NONE.  */
11548     case EM_TI_C6000:/* R_C6000_NONE.  */
11549     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11550     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11551     case EM_XC16X:
11552     case EM_C166:    /* R_XC16X_NONE.  */
11553     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11554     case EM_NIOS32:  /* R_NIOS_NONE.  */
11555     case EM_OR1K:    /* R_OR1K_NONE. */
11556       return reloc_type == 0;
11557     case EM_AARCH64:
11558       return reloc_type == 0 || reloc_type == 256;
11559     case EM_NDS32:
11560       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11561               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11562               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11563               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11564               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11565     case EM_XTENSA_OLD:
11566     case EM_XTENSA:
11567       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11568               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11569               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11570               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11571     case EM_METAG:
11572       return reloc_type == 3; /* R_METAG_NONE.  */
11573     }
11574   return FALSE;
11575 }
11576
11577 /* Apply relocations to a section.
11578    Note: So far support has been added only for those relocations
11579    which can be found in debug sections.
11580    FIXME: Add support for more relocations ?  */
11581
11582 static void
11583 apply_relocations (void * file,
11584                    Elf_Internal_Shdr * section,
11585                    unsigned char * start)
11586 {
11587   Elf_Internal_Shdr * relsec;
11588   unsigned char * end = start + section->sh_size;
11589
11590   if (elf_header.e_type != ET_REL)
11591     return;
11592
11593   /* Find the reloc section associated with the section.  */
11594   for (relsec = section_headers;
11595        relsec < section_headers + elf_header.e_shnum;
11596        ++relsec)
11597     {
11598       bfd_boolean is_rela;
11599       unsigned long num_relocs;
11600       Elf_Internal_Rela * relocs;
11601       Elf_Internal_Rela * rp;
11602       Elf_Internal_Shdr * symsec;
11603       Elf_Internal_Sym * symtab;
11604       unsigned long num_syms;
11605       Elf_Internal_Sym * sym;
11606
11607       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11608           || relsec->sh_info >= elf_header.e_shnum
11609           || section_headers + relsec->sh_info != section
11610           || relsec->sh_size == 0
11611           || relsec->sh_link >= elf_header.e_shnum)
11612         continue;
11613
11614       is_rela = relsec->sh_type == SHT_RELA;
11615
11616       if (is_rela)
11617         {
11618           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11619                                   relsec->sh_size, & relocs, & num_relocs))
11620             return;
11621         }
11622       else
11623         {
11624           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11625                                  relsec->sh_size, & relocs, & num_relocs))
11626             return;
11627         }
11628
11629       /* SH uses RELA but uses in place value instead of the addend field.  */
11630       if (elf_header.e_machine == EM_SH)
11631         is_rela = FALSE;
11632
11633       symsec = section_headers + relsec->sh_link;
11634       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11635
11636       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11637         {
11638           bfd_vma         addend;
11639           unsigned int    reloc_type;
11640           unsigned int    reloc_size;
11641           unsigned char * rloc;
11642           unsigned long   sym_index;
11643
11644           reloc_type = get_reloc_type (rp->r_info);
11645
11646           if (target_specific_reloc_handling (rp, start, symtab))
11647             continue;
11648           else if (is_none_reloc (reloc_type))
11649             continue;
11650           else if (is_32bit_abs_reloc (reloc_type)
11651                    || is_32bit_pcrel_reloc (reloc_type))
11652             reloc_size = 4;
11653           else if (is_64bit_abs_reloc (reloc_type)
11654                    || is_64bit_pcrel_reloc (reloc_type))
11655             reloc_size = 8;
11656           else if (is_24bit_abs_reloc (reloc_type))
11657             reloc_size = 3;
11658           else if (is_16bit_abs_reloc (reloc_type))
11659             reloc_size = 2;
11660           else
11661             {
11662               static unsigned int prev_reloc = 0;
11663               if (reloc_type != prev_reloc)
11664                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11665                       reloc_type, printable_section_name (section));
11666               prev_reloc = reloc_type;
11667               continue;
11668             }
11669
11670           rloc = start + rp->r_offset;
11671           if ((rloc + reloc_size) > end || (rloc < start))
11672             {
11673               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11674                     (unsigned long) rp->r_offset,
11675                     printable_section_name (section));
11676               continue;
11677             }
11678
11679           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11680           if (sym_index >= num_syms)
11681             {
11682               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11683                     sym_index, printable_section_name (section));
11684               continue;
11685             }
11686           sym = symtab + sym_index;
11687
11688           /* If the reloc has a symbol associated with it,
11689              make sure that it is of an appropriate type.
11690
11691              Relocations against symbols without type can happen.
11692              Gcc -feliminate-dwarf2-dups may generate symbols
11693              without type for debug info.
11694
11695              Icc generates relocations against function symbols
11696              instead of local labels.
11697
11698              Relocations against object symbols can happen, eg when
11699              referencing a global array.  For an example of this see
11700              the _clz.o binary in libgcc.a.  */
11701           if (sym != symtab
11702               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11703             {
11704               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11705                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11706                     (long int)(rp - relocs),
11707                     printable_section_name (relsec));
11708               continue;
11709             }
11710
11711           addend = 0;
11712           if (is_rela)
11713             addend += rp->r_addend;
11714           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11715              partial_inplace.  */
11716           if (!is_rela
11717               || (elf_header.e_machine == EM_XTENSA
11718                   && reloc_type == 1)
11719               || ((elf_header.e_machine == EM_PJ
11720                    || elf_header.e_machine == EM_PJ_OLD)
11721                   && reloc_type == 1)
11722               || ((elf_header.e_machine == EM_D30V
11723                    || elf_header.e_machine == EM_CYGNUS_D30V)
11724                   && reloc_type == 12))
11725             addend += byte_get (rloc, reloc_size);
11726
11727           if (is_32bit_pcrel_reloc (reloc_type)
11728               || is_64bit_pcrel_reloc (reloc_type))
11729             {
11730               /* On HPPA, all pc-relative relocations are biased by 8.  */
11731               if (elf_header.e_machine == EM_PARISC)
11732                 addend -= 8;
11733               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11734                         reloc_size);
11735             }
11736           else
11737             byte_put (rloc, addend + sym->st_value, reloc_size);
11738         }
11739
11740       free (symtab);
11741       free (relocs);
11742       break;
11743     }
11744 }
11745
11746 #ifdef SUPPORT_DISASSEMBLY
11747 static int
11748 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11749 {
11750   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11751
11752   /* FIXME: XXX -- to be done --- XXX */
11753
11754   return 1;
11755 }
11756 #endif
11757
11758 /* Reads in the contents of SECTION from FILE, returning a pointer
11759    to a malloc'ed buffer or NULL if something went wrong.  */
11760
11761 static char *
11762 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11763 {
11764   bfd_size_type num_bytes;
11765
11766   num_bytes = section->sh_size;
11767
11768   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11769     {
11770       printf (_("\nSection '%s' has no data to dump.\n"),
11771               printable_section_name (section));
11772       return NULL;
11773     }
11774
11775   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11776                              _("section contents"));
11777 }
11778
11779
11780 static void
11781 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11782 {
11783   Elf_Internal_Shdr * relsec;
11784   bfd_size_type num_bytes;
11785   char * data;
11786   char * end;
11787   char * start;
11788   bfd_boolean some_strings_shown;
11789
11790   start = get_section_contents (section, file);
11791   if (start == NULL)
11792     return;
11793
11794   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11795
11796   /* If the section being dumped has relocations against it the user might
11797      be expecting these relocations to have been applied.  Check for this
11798      case and issue a warning message in order to avoid confusion.
11799      FIXME: Maybe we ought to have an option that dumps a section with
11800      relocs applied ?  */
11801   for (relsec = section_headers;
11802        relsec < section_headers + elf_header.e_shnum;
11803        ++relsec)
11804     {
11805       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11806           || relsec->sh_info >= elf_header.e_shnum
11807           || section_headers + relsec->sh_info != section
11808           || relsec->sh_size == 0
11809           || relsec->sh_link >= elf_header.e_shnum)
11810         continue;
11811
11812       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11813       break;
11814     }
11815
11816   num_bytes = section->sh_size;
11817   data = start;
11818   end  = start + num_bytes;
11819   some_strings_shown = FALSE;
11820
11821   while (data < end)
11822     {
11823       while (!ISPRINT (* data))
11824         if (++ data >= end)
11825           break;
11826
11827       if (data < end)
11828         {
11829           size_t maxlen = end - data;
11830
11831 #ifndef __MSVCRT__
11832           /* PR 11128: Use two separate invocations in order to work
11833              around bugs in the Solaris 8 implementation of printf.  */
11834           printf ("  [%6tx]  ", data - start);
11835 #else
11836           printf ("  [%6Ix]  ", (size_t) (data - start));
11837 #endif
11838           if (maxlen > 0)
11839             {
11840               print_symbol ((int) maxlen, data);
11841               putchar ('\n');
11842               data += strnlen (data, maxlen);
11843             }
11844           else
11845             {
11846               printf (_("<corrupt>\n"));
11847               data = end;
11848             }
11849           some_strings_shown = TRUE;
11850         }
11851     }
11852
11853   if (! some_strings_shown)
11854     printf (_("  No strings found in this section."));
11855
11856   free (start);
11857
11858   putchar ('\n');
11859 }
11860
11861 static void
11862 dump_section_as_bytes (Elf_Internal_Shdr * section,
11863                        FILE * file,
11864                        bfd_boolean relocate)
11865 {
11866   Elf_Internal_Shdr * relsec;
11867   bfd_size_type bytes;
11868   bfd_vma addr;
11869   unsigned char * data;
11870   unsigned char * start;
11871
11872   start = (unsigned char *) get_section_contents (section, file);
11873   if (start == NULL)
11874     return;
11875
11876   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11877
11878   if (relocate)
11879     {
11880       apply_relocations (file, section, start);
11881     }
11882   else
11883     {
11884       /* If the section being dumped has relocations against it the user might
11885          be expecting these relocations to have been applied.  Check for this
11886          case and issue a warning message in order to avoid confusion.
11887          FIXME: Maybe we ought to have an option that dumps a section with
11888          relocs applied ?  */
11889       for (relsec = section_headers;
11890            relsec < section_headers + elf_header.e_shnum;
11891            ++relsec)
11892         {
11893           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11894               || relsec->sh_info >= elf_header.e_shnum
11895               || section_headers + relsec->sh_info != section
11896               || relsec->sh_size == 0
11897               || relsec->sh_link >= elf_header.e_shnum)
11898             continue;
11899
11900           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11901           break;
11902         }
11903     }
11904
11905   addr = section->sh_addr;
11906   bytes = section->sh_size;
11907   data = start;
11908
11909   while (bytes)
11910     {
11911       int j;
11912       int k;
11913       int lbytes;
11914
11915       lbytes = (bytes > 16 ? 16 : bytes);
11916
11917       printf ("  0x%8.8lx ", (unsigned long) addr);
11918
11919       for (j = 0; j < 16; j++)
11920         {
11921           if (j < lbytes)
11922             printf ("%2.2x", data[j]);
11923           else
11924             printf ("  ");
11925
11926           if ((j & 3) == 3)
11927             printf (" ");
11928         }
11929
11930       for (j = 0; j < lbytes; j++)
11931         {
11932           k = data[j];
11933           if (k >= ' ' && k < 0x7f)
11934             printf ("%c", k);
11935           else
11936             printf (".");
11937         }
11938
11939       putchar ('\n');
11940
11941       data  += lbytes;
11942       addr  += lbytes;
11943       bytes -= lbytes;
11944     }
11945
11946   free (start);
11947
11948   putchar ('\n');
11949 }
11950
11951 /* Uncompresses a section that was compressed using zlib, in place.  */
11952
11953 static int
11954 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11955                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11956 {
11957 #ifndef HAVE_ZLIB_H
11958   return FALSE;
11959 #else
11960   dwarf_size_type compressed_size = *size;
11961   unsigned char * compressed_buffer = *buffer;
11962   dwarf_size_type uncompressed_size;
11963   unsigned char * uncompressed_buffer;
11964   z_stream strm;
11965   int rc;
11966   dwarf_size_type header_size = 12;
11967
11968   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11969      by the uncompressed section size, 8 bytes in big-endian order.  */
11970   if (compressed_size < header_size
11971       || ! streq ((char *) compressed_buffer, "ZLIB"))
11972     return 0;
11973
11974   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11975   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11976   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11977   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11978   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11979   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11980   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11981   uncompressed_size += compressed_buffer[11];
11982
11983   /* It is possible the section consists of several compressed
11984      buffers concatenated together, so we uncompress in a loop.  */
11985   strm.zalloc = NULL;
11986   strm.zfree = NULL;
11987   strm.opaque = NULL;
11988   strm.avail_in = compressed_size - header_size;
11989   strm.next_in = (Bytef *) compressed_buffer + header_size;
11990   strm.avail_out = uncompressed_size;
11991   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11992
11993   rc = inflateInit (& strm);
11994   while (strm.avail_in > 0)
11995     {
11996       if (rc != Z_OK)
11997         goto fail;
11998       strm.next_out = ((Bytef *) uncompressed_buffer
11999                        + (uncompressed_size - strm.avail_out));
12000       rc = inflate (&strm, Z_FINISH);
12001       if (rc != Z_STREAM_END)
12002         goto fail;
12003       rc = inflateReset (& strm);
12004     }
12005   rc = inflateEnd (& strm);
12006   if (rc != Z_OK
12007       || strm.avail_out != 0)
12008     goto fail;
12009
12010   free (compressed_buffer);
12011   *buffer = uncompressed_buffer;
12012   *size = uncompressed_size;
12013   return 1;
12014
12015  fail:
12016   free (uncompressed_buffer);
12017   /* Indicate decompression failure.  */
12018   *buffer = NULL;
12019   return 0;
12020 #endif  /* HAVE_ZLIB_H */
12021 }
12022
12023 static int
12024 load_specific_debug_section (enum dwarf_section_display_enum debug,
12025                              Elf_Internal_Shdr * sec, void * file)
12026 {
12027   struct dwarf_section * section = &debug_displays [debug].section;
12028   char buf [64];
12029
12030   /* If it is already loaded, do nothing.  */
12031   if (section->start != NULL)
12032     return 1;
12033
12034   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12035   section->address = sec->sh_addr;
12036   section->user_data = NULL;
12037   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12038                                                sec->sh_offset, 1,
12039                                                sec->sh_size, buf);
12040   if (section->start == NULL)
12041     section->size = 0;
12042   else
12043     {
12044       section->size = sec->sh_size;
12045       if (uncompress_section_contents (&section->start, &section->size))
12046         sec->sh_size = section->size;
12047     }
12048
12049   if (section->start == NULL)
12050     return 0;
12051
12052   if (debug_displays [debug].relocate)
12053     apply_relocations ((FILE *) file, sec, section->start);
12054
12055   return 1;
12056 }
12057
12058 /* If this is not NULL, load_debug_section will only look for sections
12059    within the list of sections given here.  */
12060 unsigned int *section_subset = NULL;
12061
12062 int
12063 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12064 {
12065   struct dwarf_section * section = &debug_displays [debug].section;
12066   Elf_Internal_Shdr * sec;
12067
12068   /* Locate the debug section.  */
12069   sec = find_section_in_set (section->uncompressed_name, section_subset);
12070   if (sec != NULL)
12071     section->name = section->uncompressed_name;
12072   else
12073     {
12074       sec = find_section_in_set (section->compressed_name, section_subset);
12075       if (sec != NULL)
12076         section->name = section->compressed_name;
12077     }
12078   if (sec == NULL)
12079     return 0;
12080
12081   /* If we're loading from a subset of sections, and we've loaded
12082      a section matching this name before, it's likely that it's a
12083      different one.  */
12084   if (section_subset != NULL)
12085     free_debug_section (debug);
12086
12087   return load_specific_debug_section (debug, sec, (FILE *) file);
12088 }
12089
12090 void
12091 free_debug_section (enum dwarf_section_display_enum debug)
12092 {
12093   struct dwarf_section * section = &debug_displays [debug].section;
12094
12095   if (section->start == NULL)
12096     return;
12097
12098   free ((char *) section->start);
12099   section->start = NULL;
12100   section->address = 0;
12101   section->size = 0;
12102 }
12103
12104 static int
12105 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12106 {
12107   char * name = SECTION_NAME (section);
12108   const char * print_name = printable_section_name (section);
12109   bfd_size_type length;
12110   int result = 1;
12111   int i;
12112
12113   length = section->sh_size;
12114   if (length == 0)
12115     {
12116       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12117       return 0;
12118     }
12119   if (section->sh_type == SHT_NOBITS)
12120     {
12121       /* There is no point in dumping the contents of a debugging section
12122          which has the NOBITS type - the bits in the file will be random.
12123          This can happen when a file containing a .eh_frame section is
12124          stripped with the --only-keep-debug command line option.  */
12125       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12126               print_name);
12127       return 0;
12128     }
12129
12130   if (const_strneq (name, ".gnu.linkonce.wi."))
12131     name = ".debug_info";
12132
12133   /* See if we know how to display the contents of this section.  */
12134   for (i = 0; i < max; i++)
12135     if (streq (debug_displays[i].section.uncompressed_name, name)
12136         || (i == line && const_strneq (name, ".debug_line."))
12137         || streq (debug_displays[i].section.compressed_name, name))
12138       {
12139         struct dwarf_section * sec = &debug_displays [i].section;
12140         int secondary = (section != find_section (name));
12141
12142         if (secondary)
12143           free_debug_section ((enum dwarf_section_display_enum) i);
12144
12145         if (i == line && const_strneq (name, ".debug_line."))
12146           sec->name = name;
12147         else if (streq (sec->uncompressed_name, name))
12148           sec->name = sec->uncompressed_name;
12149         else
12150           sec->name = sec->compressed_name;
12151         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12152                                          section, file))
12153           {
12154             /* If this debug section is part of a CU/TU set in a .dwp file,
12155                restrict load_debug_section to the sections in that set.  */
12156             section_subset = find_cu_tu_set (file, shndx);
12157
12158             result &= debug_displays[i].display (sec, file);
12159
12160             section_subset = NULL;
12161
12162             if (secondary || (i != info && i != abbrev))
12163               free_debug_section ((enum dwarf_section_display_enum) i);
12164           }
12165
12166         break;
12167       }
12168
12169   if (i == max)
12170     {
12171       printf (_("Unrecognized debug section: %s\n"), print_name);
12172       result = 0;
12173     }
12174
12175   return result;
12176 }
12177
12178 /* Set DUMP_SECTS for all sections where dumps were requested
12179    based on section name.  */
12180
12181 static void
12182 initialise_dumps_byname (void)
12183 {
12184   struct dump_list_entry * cur;
12185
12186   for (cur = dump_sects_byname; cur; cur = cur->next)
12187     {
12188       unsigned int i;
12189       int any;
12190
12191       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12192         if (streq (SECTION_NAME (section_headers + i), cur->name))
12193           {
12194             request_dump_bynumber (i, cur->type);
12195             any = 1;
12196           }
12197
12198       if (!any)
12199         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12200               cur->name);
12201     }
12202 }
12203
12204 static void
12205 process_section_contents (FILE * file)
12206 {
12207   Elf_Internal_Shdr * section;
12208   unsigned int i;
12209
12210   if (! do_dump)
12211     return;
12212
12213   initialise_dumps_byname ();
12214
12215   for (i = 0, section = section_headers;
12216        i < elf_header.e_shnum && i < num_dump_sects;
12217        i++, section++)
12218     {
12219 #ifdef SUPPORT_DISASSEMBLY
12220       if (dump_sects[i] & DISASS_DUMP)
12221         disassemble_section (section, file);
12222 #endif
12223       if (dump_sects[i] & HEX_DUMP)
12224         dump_section_as_bytes (section, file, FALSE);
12225
12226       if (dump_sects[i] & RELOC_DUMP)
12227         dump_section_as_bytes (section, file, TRUE);
12228
12229       if (dump_sects[i] & STRING_DUMP)
12230         dump_section_as_strings (section, file);
12231
12232       if (dump_sects[i] & DEBUG_DUMP)
12233         display_debug_section (i, section, file);
12234     }
12235
12236   /* Check to see if the user requested a
12237      dump of a section that does not exist.  */
12238   while (i++ < num_dump_sects)
12239     if (dump_sects[i])
12240       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12241 }
12242
12243 static void
12244 process_mips_fpe_exception (int mask)
12245 {
12246   if (mask)
12247     {
12248       int first = 1;
12249       if (mask & OEX_FPU_INEX)
12250         fputs ("INEX", stdout), first = 0;
12251       if (mask & OEX_FPU_UFLO)
12252         printf ("%sUFLO", first ? "" : "|"), first = 0;
12253       if (mask & OEX_FPU_OFLO)
12254         printf ("%sOFLO", first ? "" : "|"), first = 0;
12255       if (mask & OEX_FPU_DIV0)
12256         printf ("%sDIV0", first ? "" : "|"), first = 0;
12257       if (mask & OEX_FPU_INVAL)
12258         printf ("%sINVAL", first ? "" : "|");
12259     }
12260   else
12261     fputs ("0", stdout);
12262 }
12263
12264 /* Display's the value of TAG at location P.  If TAG is
12265    greater than 0 it is assumed to be an unknown tag, and
12266    a message is printed to this effect.  Otherwise it is
12267    assumed that a message has already been printed.
12268
12269    If the bottom bit of TAG is set it assumed to have a
12270    string value, otherwise it is assumed to have an integer
12271    value.
12272
12273    Returns an updated P pointing to the first unread byte
12274    beyond the end of TAG's value.
12275
12276    Reads at or beyond END will not be made.  */
12277
12278 static unsigned char *
12279 display_tag_value (int tag,
12280                    unsigned char * p,
12281                    const unsigned char * const end)
12282 {
12283   unsigned long val;
12284
12285   if (tag > 0)
12286     printf ("  Tag_unknown_%d: ", tag);
12287
12288   if (p >= end)
12289     {
12290       warn (_("<corrupt tag>\n"));
12291     }
12292   else if (tag & 1)
12293     {
12294       /* PR 17531 file: 027-19978-0.004.  */
12295       size_t maxlen = (end - p) - 1;
12296
12297       putchar ('"');
12298       if (maxlen > 0)
12299         {
12300           print_symbol ((int) maxlen, (const char *) p);
12301           p += strnlen ((char *) p, maxlen) + 1;
12302         }
12303       else
12304         {
12305           printf (_("<corrupt string tag>"));
12306           p = (unsigned char *) end;
12307         }
12308       printf ("\"\n");
12309     }
12310   else
12311     {
12312       unsigned int len;
12313
12314       val = read_uleb128 (p, &len, end);
12315       p += len;
12316       printf ("%ld (0x%lx)\n", val, val);
12317     }
12318
12319   assert (p <= end);
12320   return p;
12321 }
12322
12323 /* ARM EABI attributes section.  */
12324 typedef struct
12325 {
12326   unsigned int tag;
12327   const char * name;
12328   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12329   unsigned int type;
12330   const char ** table;
12331 } arm_attr_public_tag;
12332
12333 static const char * arm_attr_tag_CPU_arch[] =
12334   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12335    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12336 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12337 static const char * arm_attr_tag_THUMB_ISA_use[] =
12338   {"No", "Thumb-1", "Thumb-2"};
12339 static const char * arm_attr_tag_FP_arch[] =
12340   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12341    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12342 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12343 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12344   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12345 static const char * arm_attr_tag_PCS_config[] =
12346   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12347    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12348 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12349   {"V6", "SB", "TLS", "Unused"};
12350 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12351   {"Absolute", "PC-relative", "SB-relative", "None"};
12352 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12353   {"Absolute", "PC-relative", "None"};
12354 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12355   {"None", "direct", "GOT-indirect"};
12356 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12357   {"None", "??? 1", "2", "??? 3", "4"};
12358 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12359 static const char * arm_attr_tag_ABI_FP_denormal[] =
12360   {"Unused", "Needed", "Sign only"};
12361 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12362 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12363 static const char * arm_attr_tag_ABI_FP_number_model[] =
12364   {"Unused", "Finite", "RTABI", "IEEE 754"};
12365 static const char * arm_attr_tag_ABI_enum_size[] =
12366   {"Unused", "small", "int", "forced to int"};
12367 static const char * arm_attr_tag_ABI_HardFP_use[] =
12368   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12369 static const char * arm_attr_tag_ABI_VFP_args[] =
12370   {"AAPCS", "VFP registers", "custom", "compatible"};
12371 static const char * arm_attr_tag_ABI_WMMX_args[] =
12372   {"AAPCS", "WMMX registers", "custom"};
12373 static const char * arm_attr_tag_ABI_optimization_goals[] =
12374   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12375     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12376 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12377   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12378     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12379 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12380 static const char * arm_attr_tag_FP_HP_extension[] =
12381   {"Not Allowed", "Allowed"};
12382 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12383   {"None", "IEEE 754", "Alternative Format"};
12384 static const char * arm_attr_tag_MPextension_use[] =
12385   {"Not Allowed", "Allowed"};
12386 static const char * arm_attr_tag_DIV_use[] =
12387   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12388     "Allowed in v7-A with integer division extension"};
12389 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12390 static const char * arm_attr_tag_Virtualization_use[] =
12391   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12392     "TrustZone and Virtualization Extensions"};
12393 static const char * arm_attr_tag_MPextension_use_legacy[] =
12394   {"Not Allowed", "Allowed"};
12395
12396 #define LOOKUP(id, name) \
12397   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12398 static arm_attr_public_tag arm_attr_public_tags[] =
12399 {
12400   {4, "CPU_raw_name", 1, NULL},
12401   {5, "CPU_name", 1, NULL},
12402   LOOKUP(6, CPU_arch),
12403   {7, "CPU_arch_profile", 0, NULL},
12404   LOOKUP(8, ARM_ISA_use),
12405   LOOKUP(9, THUMB_ISA_use),
12406   LOOKUP(10, FP_arch),
12407   LOOKUP(11, WMMX_arch),
12408   LOOKUP(12, Advanced_SIMD_arch),
12409   LOOKUP(13, PCS_config),
12410   LOOKUP(14, ABI_PCS_R9_use),
12411   LOOKUP(15, ABI_PCS_RW_data),
12412   LOOKUP(16, ABI_PCS_RO_data),
12413   LOOKUP(17, ABI_PCS_GOT_use),
12414   LOOKUP(18, ABI_PCS_wchar_t),
12415   LOOKUP(19, ABI_FP_rounding),
12416   LOOKUP(20, ABI_FP_denormal),
12417   LOOKUP(21, ABI_FP_exceptions),
12418   LOOKUP(22, ABI_FP_user_exceptions),
12419   LOOKUP(23, ABI_FP_number_model),
12420   {24, "ABI_align_needed", 0, NULL},
12421   {25, "ABI_align_preserved", 0, NULL},
12422   LOOKUP(26, ABI_enum_size),
12423   LOOKUP(27, ABI_HardFP_use),
12424   LOOKUP(28, ABI_VFP_args),
12425   LOOKUP(29, ABI_WMMX_args),
12426   LOOKUP(30, ABI_optimization_goals),
12427   LOOKUP(31, ABI_FP_optimization_goals),
12428   {32, "compatibility", 0, NULL},
12429   LOOKUP(34, CPU_unaligned_access),
12430   LOOKUP(36, FP_HP_extension),
12431   LOOKUP(38, ABI_FP_16bit_format),
12432   LOOKUP(42, MPextension_use),
12433   LOOKUP(44, DIV_use),
12434   {64, "nodefaults", 0, NULL},
12435   {65, "also_compatible_with", 0, NULL},
12436   LOOKUP(66, T2EE_use),
12437   {67, "conformance", 1, NULL},
12438   LOOKUP(68, Virtualization_use),
12439   LOOKUP(70, MPextension_use_legacy)
12440 };
12441 #undef LOOKUP
12442
12443 static unsigned char *
12444 display_arm_attribute (unsigned char * p,
12445                        const unsigned char * const end)
12446 {
12447   unsigned int tag;
12448   unsigned int len;
12449   unsigned int val;
12450   arm_attr_public_tag * attr;
12451   unsigned i;
12452   unsigned int type;
12453
12454   tag = read_uleb128 (p, &len, end);
12455   p += len;
12456   attr = NULL;
12457   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12458     {
12459       if (arm_attr_public_tags[i].tag == tag)
12460         {
12461           attr = &arm_attr_public_tags[i];
12462           break;
12463         }
12464     }
12465
12466   if (attr)
12467     {
12468       printf ("  Tag_%s: ", attr->name);
12469       switch (attr->type)
12470         {
12471         case 0:
12472           switch (tag)
12473             {
12474             case 7: /* Tag_CPU_arch_profile.  */
12475               val = read_uleb128 (p, &len, end);
12476               p += len;
12477               switch (val)
12478                 {
12479                 case 0: printf (_("None\n")); break;
12480                 case 'A': printf (_("Application\n")); break;
12481                 case 'R': printf (_("Realtime\n")); break;
12482                 case 'M': printf (_("Microcontroller\n")); break;
12483                 case 'S': printf (_("Application or Realtime\n")); break;
12484                 default: printf ("??? (%d)\n", val); break;
12485                 }
12486               break;
12487
12488             case 24: /* Tag_align_needed.  */
12489               val = read_uleb128 (p, &len, end);
12490               p += len;
12491               switch (val)
12492                 {
12493                 case 0: printf (_("None\n")); break;
12494                 case 1: printf (_("8-byte\n")); break;
12495                 case 2: printf (_("4-byte\n")); break;
12496                 case 3: printf ("??? 3\n"); break;
12497                 default:
12498                   if (val <= 12)
12499                     printf (_("8-byte and up to %d-byte extended\n"),
12500                             1 << val);
12501                   else
12502                     printf ("??? (%d)\n", val);
12503                   break;
12504                 }
12505               break;
12506
12507             case 25: /* Tag_align_preserved.  */
12508               val = read_uleb128 (p, &len, end);
12509               p += len;
12510               switch (val)
12511                 {
12512                 case 0: printf (_("None\n")); break;
12513                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12514                 case 2: printf (_("8-byte\n")); break;
12515                 case 3: printf ("??? 3\n"); break;
12516                 default:
12517                   if (val <= 12)
12518                     printf (_("8-byte and up to %d-byte extended\n"),
12519                             1 << val);
12520                   else
12521                     printf ("??? (%d)\n", val);
12522                   break;
12523                 }
12524               break;
12525
12526             case 32: /* Tag_compatibility.  */
12527               {
12528                 val = read_uleb128 (p, &len, end);
12529                 p += len;
12530                 printf (_("flag = %d, vendor = "), val);
12531                 if (p < end - 1)
12532                   {
12533                     size_t maxlen = (end - p) - 1;
12534
12535                     print_symbol ((int) maxlen, (const char *) p);
12536                     p += strnlen ((char *) p, maxlen) + 1;
12537                   }
12538                 else
12539                   {
12540                     printf (_("<corrupt>"));
12541                     p = (unsigned char *) end;
12542                   }
12543                 putchar ('\n');
12544               }
12545               break;
12546
12547             case 64: /* Tag_nodefaults.  */
12548               /* PR 17531: file: 001-505008-0.01.  */
12549               if (p < end)
12550                 p++;
12551               printf (_("True\n"));
12552               break;
12553
12554             case 65: /* Tag_also_compatible_with.  */
12555               val = read_uleb128 (p, &len, end);
12556               p += len;
12557               if (val == 6 /* Tag_CPU_arch.  */)
12558                 {
12559                   val = read_uleb128 (p, &len, end);
12560                   p += len;
12561                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12562                     printf ("??? (%d)\n", val);
12563                   else
12564                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12565                 }
12566               else
12567                 printf ("???\n");
12568               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12569                 ;
12570               break;
12571
12572             default:
12573               printf (_("<unknown: %d>\n"), tag);
12574               break;
12575             }
12576           return p;
12577
12578         case 1:
12579           return display_tag_value (-1, p, end);
12580         case 2:
12581           return display_tag_value (0, p, end);
12582
12583         default:
12584           assert (attr->type & 0x80);
12585           val = read_uleb128 (p, &len, end);
12586           p += len;
12587           type = attr->type & 0x7f;
12588           if (val >= type)
12589             printf ("??? (%d)\n", val);
12590           else
12591             printf ("%s\n", attr->table[val]);
12592           return p;
12593         }
12594     }
12595
12596   return display_tag_value (tag, p, end);
12597 }
12598
12599 static unsigned char *
12600 display_gnu_attribute (unsigned char * p,
12601                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12602                        const unsigned char * const end)
12603 {
12604   int tag;
12605   unsigned int len;
12606   int val;
12607
12608   tag = read_uleb128 (p, &len, end);
12609   p += len;
12610
12611   /* Tag_compatibility is the only generic GNU attribute defined at
12612      present.  */
12613   if (tag == 32)
12614     {
12615       val = read_uleb128 (p, &len, end);
12616       p += len;
12617
12618       printf (_("flag = %d, vendor = "), val);
12619       if (p == end)
12620         {
12621           printf (_("<corrupt>\n"));
12622           warn (_("corrupt vendor attribute\n"));
12623         }
12624       else
12625         {
12626           if (p < end - 1)
12627             {
12628               size_t maxlen = (end - p) - 1;
12629
12630               print_symbol ((int) maxlen, (const char *) p);
12631               p += strnlen ((char *) p, maxlen) + 1;
12632             }
12633           else
12634             {
12635               printf (_("<corrupt>"));
12636               p = (unsigned char *) end;
12637             }
12638           putchar ('\n');
12639         }
12640       return p;
12641     }
12642
12643   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12644     return display_proc_gnu_attribute (p, tag, end);
12645
12646   return display_tag_value (tag, p, end);
12647 }
12648
12649 static unsigned char *
12650 display_power_gnu_attribute (unsigned char * p,
12651                              int tag,
12652                              const unsigned char * const end)
12653 {
12654   unsigned int len;
12655   int val;
12656
12657   if (tag == Tag_GNU_Power_ABI_FP)
12658     {
12659       val = read_uleb128 (p, &len, end);
12660       p += len;
12661       printf ("  Tag_GNU_Power_ABI_FP: ");
12662
12663       switch (val)
12664         {
12665         case 0:
12666           printf (_("Hard or soft float\n"));
12667           break;
12668         case 1:
12669           printf (_("Hard float\n"));
12670           break;
12671         case 2:
12672           printf (_("Soft float\n"));
12673           break;
12674         case 3:
12675           printf (_("Single-precision hard float\n"));
12676           break;
12677         default:
12678           printf ("??? (%d)\n", val);
12679           break;
12680         }
12681       return p;
12682    }
12683
12684   if (tag == Tag_GNU_Power_ABI_Vector)
12685     {
12686       val = read_uleb128 (p, &len, end);
12687       p += len;
12688       printf ("  Tag_GNU_Power_ABI_Vector: ");
12689       switch (val)
12690         {
12691         case 0:
12692           printf (_("Any\n"));
12693           break;
12694         case 1:
12695           printf (_("Generic\n"));
12696           break;
12697         case 2:
12698           printf ("AltiVec\n");
12699           break;
12700         case 3:
12701           printf ("SPE\n");
12702           break;
12703         default:
12704           printf ("??? (%d)\n", val);
12705           break;
12706         }
12707       return p;
12708    }
12709
12710   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12711     {
12712       if (p == end)
12713         {
12714           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12715           return p;
12716         }
12717
12718       val = read_uleb128 (p, &len, end);
12719       p += len;
12720       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12721       switch (val)
12722        {
12723        case 0:
12724          printf (_("Any\n"));
12725          break;
12726        case 1:
12727          printf ("r3/r4\n");
12728          break;
12729        case 2:
12730          printf (_("Memory\n"));
12731          break;
12732        default:
12733          printf ("??? (%d)\n", val);
12734          break;
12735        }
12736       return p;
12737     }
12738
12739   return display_tag_value (tag & 1, p, end);
12740 }
12741
12742 static void
12743 display_sparc_hwcaps (int mask)
12744 {
12745   if (mask)
12746     {
12747       int first = 1;
12748
12749       if (mask & ELF_SPARC_HWCAP_MUL32)
12750         fputs ("mul32", stdout), first = 0;
12751       if (mask & ELF_SPARC_HWCAP_DIV32)
12752         printf ("%sdiv32", first ? "" : "|"), first = 0;
12753       if (mask & ELF_SPARC_HWCAP_FSMULD)
12754         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12755       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12756         printf ("%sv8plus", first ? "" : "|"), first = 0;
12757       if (mask & ELF_SPARC_HWCAP_POPC)
12758         printf ("%spopc", first ? "" : "|"), first = 0;
12759       if (mask & ELF_SPARC_HWCAP_VIS)
12760         printf ("%svis", first ? "" : "|"), first = 0;
12761       if (mask & ELF_SPARC_HWCAP_VIS2)
12762         printf ("%svis2", first ? "" : "|"), first = 0;
12763       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12764         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12765       if (mask & ELF_SPARC_HWCAP_FMAF)
12766         printf ("%sfmaf", first ? "" : "|"), first = 0;
12767       if (mask & ELF_SPARC_HWCAP_VIS3)
12768         printf ("%svis3", first ? "" : "|"), first = 0;
12769       if (mask & ELF_SPARC_HWCAP_HPC)
12770         printf ("%shpc", first ? "" : "|"), first = 0;
12771       if (mask & ELF_SPARC_HWCAP_RANDOM)
12772         printf ("%srandom", first ? "" : "|"), first = 0;
12773       if (mask & ELF_SPARC_HWCAP_TRANS)
12774         printf ("%strans", first ? "" : "|"), first = 0;
12775       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12776         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12777       if (mask & ELF_SPARC_HWCAP_IMA)
12778         printf ("%sima", first ? "" : "|"), first = 0;
12779       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12780         printf ("%scspare", first ? "" : "|"), first = 0;
12781     }
12782   else
12783     fputc ('0', stdout);
12784   fputc ('\n', stdout);
12785 }
12786
12787 static void
12788 display_sparc_hwcaps2 (int mask)
12789 {
12790   if (mask)
12791     {
12792       int first = 1;
12793
12794       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12795         fputs ("fjathplus", stdout), first = 0;
12796       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12797         printf ("%svis3b", first ? "" : "|"), first = 0;
12798       if (mask & ELF_SPARC_HWCAP2_ADP)
12799         printf ("%sadp", first ? "" : "|"), first = 0;
12800       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12801         printf ("%ssparc5", first ? "" : "|"), first = 0;
12802       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12803         printf ("%smwait", first ? "" : "|"), first = 0;
12804       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12805         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12806       if (mask & ELF_SPARC_HWCAP2_XMONT)
12807         printf ("%sxmont2", first ? "" : "|"), first = 0;
12808       if (mask & ELF_SPARC_HWCAP2_NSEC)
12809         printf ("%snsec", first ? "" : "|"), first = 0;
12810       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12811         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12812       if (mask & ELF_SPARC_HWCAP2_FJDES)
12813         printf ("%sfjdes", first ? "" : "|"), first = 0;
12814       if (mask & ELF_SPARC_HWCAP2_FJAES)
12815         printf ("%sfjaes", first ? "" : "|"), first = 0;
12816     }
12817   else
12818     fputc ('0', stdout);
12819   fputc ('\n', stdout);
12820 }
12821
12822 static unsigned char *
12823 display_sparc_gnu_attribute (unsigned char * p,
12824                              int tag,
12825                              const unsigned char * const end)
12826 {
12827   unsigned int len;
12828   int val;
12829
12830   if (tag == Tag_GNU_Sparc_HWCAPS)
12831     {
12832       val = read_uleb128 (p, &len, end);
12833       p += len;
12834       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12835       display_sparc_hwcaps (val);
12836       return p;
12837     }
12838   if (tag == Tag_GNU_Sparc_HWCAPS2)
12839     {
12840       val = read_uleb128 (p, &len, end);
12841       p += len;
12842       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12843       display_sparc_hwcaps2 (val);
12844       return p;
12845     }
12846
12847   return display_tag_value (tag, p, end);
12848 }
12849
12850 static void
12851 print_mips_fp_abi_value (int val)
12852 {
12853   switch (val)
12854     {
12855     case Val_GNU_MIPS_ABI_FP_ANY:
12856       printf (_("Hard or soft float\n"));
12857       break;
12858     case Val_GNU_MIPS_ABI_FP_DOUBLE:
12859       printf (_("Hard float (double precision)\n"));
12860       break;
12861     case Val_GNU_MIPS_ABI_FP_SINGLE:
12862       printf (_("Hard float (single precision)\n"));
12863       break;
12864     case Val_GNU_MIPS_ABI_FP_SOFT:
12865       printf (_("Soft float\n"));
12866       break;
12867     case Val_GNU_MIPS_ABI_FP_OLD_64:
12868       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12869       break;
12870     case Val_GNU_MIPS_ABI_FP_XX:
12871       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12872       break;
12873     case Val_GNU_MIPS_ABI_FP_64:
12874       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12875       break;
12876     case Val_GNU_MIPS_ABI_FP_64A:
12877       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12878       break;
12879     default:
12880       printf ("??? (%d)\n", val);
12881       break;
12882     }
12883 }
12884
12885 static unsigned char *
12886 display_mips_gnu_attribute (unsigned char * p,
12887                             int tag,
12888                             const unsigned char * const end)
12889 {
12890   if (tag == Tag_GNU_MIPS_ABI_FP)
12891     {
12892       unsigned int len;
12893       int val;
12894
12895       val = read_uleb128 (p, &len, end);
12896       p += len;
12897       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12898
12899       print_mips_fp_abi_value (val);
12900
12901       return p;
12902    }
12903
12904   if (tag == Tag_GNU_MIPS_ABI_MSA)
12905     {
12906       unsigned int len;
12907       int val;
12908
12909       val = read_uleb128 (p, &len, end);
12910       p += len;
12911       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12912
12913       switch (val)
12914         {
12915         case Val_GNU_MIPS_ABI_MSA_ANY:
12916           printf (_("Any MSA or not\n"));
12917           break;
12918         case Val_GNU_MIPS_ABI_MSA_128:
12919           printf (_("128-bit MSA\n"));
12920           break;
12921         default:
12922           printf ("??? (%d)\n", val);
12923           break;
12924         }
12925       return p;
12926     }
12927
12928   return display_tag_value (tag & 1, p, end);
12929 }
12930
12931 static unsigned char *
12932 display_tic6x_attribute (unsigned char * p,
12933                          const unsigned char * const end)
12934 {
12935   int tag;
12936   unsigned int len;
12937   int val;
12938
12939   tag = read_uleb128 (p, &len, end);
12940   p += len;
12941
12942   switch (tag)
12943     {
12944     case Tag_ISA:
12945       val = read_uleb128 (p, &len, end);
12946       p += len;
12947       printf ("  Tag_ISA: ");
12948
12949       switch (val)
12950         {
12951         case C6XABI_Tag_ISA_none:
12952           printf (_("None\n"));
12953           break;
12954         case C6XABI_Tag_ISA_C62X:
12955           printf ("C62x\n");
12956           break;
12957         case C6XABI_Tag_ISA_C67X:
12958           printf ("C67x\n");
12959           break;
12960         case C6XABI_Tag_ISA_C67XP:
12961           printf ("C67x+\n");
12962           break;
12963         case C6XABI_Tag_ISA_C64X:
12964           printf ("C64x\n");
12965           break;
12966         case C6XABI_Tag_ISA_C64XP:
12967           printf ("C64x+\n");
12968           break;
12969         case C6XABI_Tag_ISA_C674X:
12970           printf ("C674x\n");
12971           break;
12972         default:
12973           printf ("??? (%d)\n", val);
12974           break;
12975         }
12976       return p;
12977
12978     case Tag_ABI_wchar_t:
12979       val = read_uleb128 (p, &len, end);
12980       p += len;
12981       printf ("  Tag_ABI_wchar_t: ");
12982       switch (val)
12983         {
12984         case 0:
12985           printf (_("Not used\n"));
12986           break;
12987         case 1:
12988           printf (_("2 bytes\n"));
12989           break;
12990         case 2:
12991           printf (_("4 bytes\n"));
12992           break;
12993         default:
12994           printf ("??? (%d)\n", val);
12995           break;
12996         }
12997       return p;
12998
12999     case Tag_ABI_stack_align_needed:
13000       val = read_uleb128 (p, &len, end);
13001       p += len;
13002       printf ("  Tag_ABI_stack_align_needed: ");
13003       switch (val)
13004         {
13005         case 0:
13006           printf (_("8-byte\n"));
13007           break;
13008         case 1:
13009           printf (_("16-byte\n"));
13010           break;
13011         default:
13012           printf ("??? (%d)\n", val);
13013           break;
13014         }
13015       return p;
13016
13017     case Tag_ABI_stack_align_preserved:
13018       val = read_uleb128 (p, &len, end);
13019       p += len;
13020       printf ("  Tag_ABI_stack_align_preserved: ");
13021       switch (val)
13022         {
13023         case 0:
13024           printf (_("8-byte\n"));
13025           break;
13026         case 1:
13027           printf (_("16-byte\n"));
13028           break;
13029         default:
13030           printf ("??? (%d)\n", val);
13031           break;
13032         }
13033       return p;
13034
13035     case Tag_ABI_DSBT:
13036       val = read_uleb128 (p, &len, end);
13037       p += len;
13038       printf ("  Tag_ABI_DSBT: ");
13039       switch (val)
13040         {
13041         case 0:
13042           printf (_("DSBT addressing not used\n"));
13043           break;
13044         case 1:
13045           printf (_("DSBT addressing used\n"));
13046           break;
13047         default:
13048           printf ("??? (%d)\n", val);
13049           break;
13050         }
13051       return p;
13052
13053     case Tag_ABI_PID:
13054       val = read_uleb128 (p, &len, end);
13055       p += len;
13056       printf ("  Tag_ABI_PID: ");
13057       switch (val)
13058         {
13059         case 0:
13060           printf (_("Data addressing position-dependent\n"));
13061           break;
13062         case 1:
13063           printf (_("Data addressing position-independent, GOT near DP\n"));
13064           break;
13065         case 2:
13066           printf (_("Data addressing position-independent, GOT far from DP\n"));
13067           break;
13068         default:
13069           printf ("??? (%d)\n", val);
13070           break;
13071         }
13072       return p;
13073
13074     case Tag_ABI_PIC:
13075       val = read_uleb128 (p, &len, end);
13076       p += len;
13077       printf ("  Tag_ABI_PIC: ");
13078       switch (val)
13079         {
13080         case 0:
13081           printf (_("Code addressing position-dependent\n"));
13082           break;
13083         case 1:
13084           printf (_("Code addressing position-independent\n"));
13085           break;
13086         default:
13087           printf ("??? (%d)\n", val);
13088           break;
13089         }
13090       return p;
13091
13092     case Tag_ABI_array_object_alignment:
13093       val = read_uleb128 (p, &len, end);
13094       p += len;
13095       printf ("  Tag_ABI_array_object_alignment: ");
13096       switch (val)
13097         {
13098         case 0:
13099           printf (_("8-byte\n"));
13100           break;
13101         case 1:
13102           printf (_("4-byte\n"));
13103           break;
13104         case 2:
13105           printf (_("16-byte\n"));
13106           break;
13107         default:
13108           printf ("??? (%d)\n", val);
13109           break;
13110         }
13111       return p;
13112
13113     case Tag_ABI_array_object_align_expected:
13114       val = read_uleb128 (p, &len, end);
13115       p += len;
13116       printf ("  Tag_ABI_array_object_align_expected: ");
13117       switch (val)
13118         {
13119         case 0:
13120           printf (_("8-byte\n"));
13121           break;
13122         case 1:
13123           printf (_("4-byte\n"));
13124           break;
13125         case 2:
13126           printf (_("16-byte\n"));
13127           break;
13128         default:
13129           printf ("??? (%d)\n", val);
13130           break;
13131         }
13132       return p;
13133
13134     case Tag_ABI_compatibility:
13135       {
13136         val = read_uleb128 (p, &len, end);
13137         p += len;
13138         printf ("  Tag_ABI_compatibility: ");
13139         printf (_("flag = %d, vendor = "), val);
13140         if (p < end - 1)
13141           {
13142             size_t maxlen = (end - p) - 1;
13143
13144             print_symbol ((int) maxlen, (const char *) p);
13145             p += strnlen ((char *) p, maxlen) + 1;
13146           }
13147         else
13148           {
13149             printf (_("<corrupt>"));
13150             p = (unsigned char *) end;
13151           }
13152         putchar ('\n');
13153         return p;
13154       }
13155
13156     case Tag_ABI_conformance:
13157       {
13158         printf ("  Tag_ABI_conformance: \"");
13159         if (p < end - 1)
13160           {
13161             size_t maxlen = (end - p) - 1;
13162
13163             print_symbol ((int) maxlen, (const char *) p);
13164             p += strnlen ((char *) p, maxlen) + 1;
13165           }
13166         else
13167           {
13168             printf (_("<corrupt>"));
13169             p = (unsigned char *) end;
13170           }
13171         printf ("\"\n");
13172         return p;
13173       }
13174     }
13175
13176   return display_tag_value (tag, p, end);
13177 }
13178
13179 static void
13180 display_raw_attribute (unsigned char * p, unsigned char * end)
13181 {
13182   unsigned long addr = 0;
13183   size_t bytes = end - p;
13184
13185   assert (end > p);
13186   while (bytes)
13187     {
13188       int j;
13189       int k;
13190       int lbytes = (bytes > 16 ? 16 : bytes);
13191
13192       printf ("  0x%8.8lx ", addr);
13193
13194       for (j = 0; j < 16; j++)
13195         {
13196           if (j < lbytes)
13197             printf ("%2.2x", p[j]);
13198           else
13199             printf ("  ");
13200
13201           if ((j & 3) == 3)
13202             printf (" ");
13203         }
13204
13205       for (j = 0; j < lbytes; j++)
13206         {
13207           k = p[j];
13208           if (k >= ' ' && k < 0x7f)
13209             printf ("%c", k);
13210           else
13211             printf (".");
13212         }
13213
13214       putchar ('\n');
13215
13216       p  += lbytes;
13217       bytes -= lbytes;
13218       addr += lbytes;
13219     }
13220
13221   putchar ('\n');
13222 }
13223
13224 static unsigned char *
13225 display_msp430x_attribute (unsigned char * p,
13226                            const unsigned char * const end)
13227 {
13228   unsigned int len;
13229   int val;
13230   int tag;
13231
13232   tag = read_uleb128 (p, & len, end);
13233   p += len;
13234
13235   switch (tag)
13236     {
13237     case OFBA_MSPABI_Tag_ISA:
13238       val = read_uleb128 (p, &len, end);
13239       p += len;
13240       printf ("  Tag_ISA: ");
13241       switch (val)
13242         {
13243         case 0: printf (_("None\n")); break;
13244         case 1: printf (_("MSP430\n")); break;
13245         case 2: printf (_("MSP430X\n")); break;
13246         default: printf ("??? (%d)\n", val); break;
13247         }
13248       break;
13249
13250     case OFBA_MSPABI_Tag_Code_Model:
13251       val = read_uleb128 (p, &len, end);
13252       p += len;
13253       printf ("  Tag_Code_Model: ");
13254       switch (val)
13255         {
13256         case 0: printf (_("None\n")); break;
13257         case 1: printf (_("Small\n")); break;
13258         case 2: printf (_("Large\n")); break;
13259         default: printf ("??? (%d)\n", val); break;
13260         }
13261       break;
13262
13263     case OFBA_MSPABI_Tag_Data_Model:
13264       val = read_uleb128 (p, &len, end);
13265       p += len;
13266       printf ("  Tag_Data_Model: ");
13267       switch (val)
13268         {
13269         case 0: printf (_("None\n")); break;
13270         case 1: printf (_("Small\n")); break;
13271         case 2: printf (_("Large\n")); break;
13272         case 3: printf (_("Restricted Large\n")); break;
13273         default: printf ("??? (%d)\n", val); break;
13274         }
13275       break;
13276
13277     default:
13278       printf (_("  <unknown tag %d>: "), tag);
13279
13280       if (tag & 1)
13281         {
13282           putchar ('"');
13283           if (p < end - 1)
13284             {
13285               size_t maxlen = (end - p) - 1;
13286
13287               print_symbol ((int) maxlen, (const char *) p);
13288               p += strnlen ((char *) p, maxlen) + 1;
13289             }
13290           else
13291             {
13292               printf (_("<corrupt>"));
13293               p = (unsigned char *) end;
13294             }
13295           printf ("\"\n");
13296         }
13297       else
13298         {
13299           val = read_uleb128 (p, &len, end);
13300           p += len;
13301           printf ("%d (0x%x)\n", val, val);
13302         }
13303       break;
13304    }
13305
13306   assert (p <= end);
13307   return p;
13308 }
13309
13310 static int
13311 process_attributes (FILE * file,
13312                     const char * public_name,
13313                     unsigned int proc_type,
13314                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13315                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13316 {
13317   Elf_Internal_Shdr * sect;
13318   unsigned i;
13319
13320   /* Find the section header so that we get the size.  */
13321   for (i = 0, sect = section_headers;
13322        i < elf_header.e_shnum;
13323        i++, sect++)
13324     {
13325       unsigned char * contents;
13326       unsigned char * p;
13327
13328       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13329         continue;
13330
13331       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13332                                              sect->sh_size, _("attributes"));
13333       if (contents == NULL)
13334         continue;
13335
13336       p = contents;
13337       if (*p == 'A')
13338         {
13339           bfd_vma section_len;
13340
13341           section_len = sect->sh_size - 1;
13342           p++;
13343
13344           while (section_len > 0)
13345             {
13346               bfd_vma attr_len;
13347               unsigned int namelen;
13348               bfd_boolean public_section;
13349               bfd_boolean gnu_section;
13350
13351               if (section_len <= 4)
13352                 {
13353                   error (_("Tag section ends prematurely\n"));
13354                   break;
13355                 }
13356               attr_len = byte_get (p, 4);
13357               p += 4;
13358
13359               if (attr_len > section_len)
13360                 {
13361                   error (_("Bad attribute length (%u > %u)\n"),
13362                           (unsigned) attr_len, (unsigned) section_len);
13363                   attr_len = section_len;
13364                 }
13365               /* PR 17531: file: 001-101425-0.004  */
13366               else if (attr_len < 5)
13367                 {
13368                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13369                   break;
13370                 }
13371
13372               section_len -= attr_len;
13373               attr_len -= 4;
13374
13375               namelen = strnlen ((char *) p, attr_len) + 1;
13376               if (namelen == 0 || namelen >= attr_len)
13377                 {
13378                   error (_("Corrupt attribute section name\n"));
13379                   break;
13380                 }
13381
13382               printf (_("Attribute Section: "));
13383               print_symbol (INT_MAX, (const char *) p);
13384               putchar ('\n');
13385
13386               if (public_name && streq ((char *) p, public_name))
13387                 public_section = TRUE;
13388               else
13389                 public_section = FALSE;
13390
13391               if (streq ((char *) p, "gnu"))
13392                 gnu_section = TRUE;
13393               else
13394                 gnu_section = FALSE;
13395
13396               p += namelen;
13397               attr_len -= namelen;
13398
13399               while (attr_len > 0 && p < contents + sect->sh_size)
13400                 {
13401                   int tag;
13402                   int val;
13403                   bfd_vma size;
13404                   unsigned char * end;
13405
13406                   /* PR binutils/17531: Safe handling of corrupt files.  */
13407                   if (attr_len < 6)
13408                     {
13409                       error (_("Unused bytes at end of section\n"));
13410                       section_len = 0;
13411                       break;
13412                     }
13413
13414                   tag = *(p++);
13415                   size = byte_get (p, 4);
13416                   if (size > attr_len)
13417                     {
13418                       error (_("Bad subsection length (%u > %u)\n"),
13419                               (unsigned) size, (unsigned) attr_len);
13420                       size = attr_len;
13421                     }
13422                   /* PR binutils/17531: Safe handling of corrupt files.  */
13423                   if (size < 6)
13424                     {
13425                       error (_("Bad subsection length (%u < 6)\n"),
13426                               (unsigned) size);
13427                       section_len = 0;
13428                       break;
13429                     }
13430
13431                   attr_len -= size;
13432                   end = p + size - 1;
13433                   assert (end <= contents + sect->sh_size);
13434                   p += 4;
13435
13436                   switch (tag)
13437                     {
13438                     case 1:
13439                       printf (_("File Attributes\n"));
13440                       break;
13441                     case 2:
13442                       printf (_("Section Attributes:"));
13443                       goto do_numlist;
13444                     case 3:
13445                       printf (_("Symbol Attributes:"));
13446                     do_numlist:
13447                       for (;;)
13448                         {
13449                           unsigned int j;
13450
13451                           val = read_uleb128 (p, &j, end);
13452                           p += j;
13453                           if (val == 0)
13454                             break;
13455                           printf (" %d", val);
13456                         }
13457                       printf ("\n");
13458                       break;
13459                     default:
13460                       printf (_("Unknown tag: %d\n"), tag);
13461                       public_section = FALSE;
13462                       break;
13463                     }
13464
13465                   if (public_section && display_pub_attribute != NULL)
13466                     {
13467                       while (p < end)
13468                         p = display_pub_attribute (p, end);
13469                       assert (p <= end);
13470                     }
13471                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13472                     {
13473                       while (p < end)
13474                         p = display_gnu_attribute (p,
13475                                                    display_proc_gnu_attribute,
13476                                                    end);
13477                       assert (p <= end);
13478                     }
13479                   else if (p < end)
13480                     {
13481                       printf (_("  Unknown attribute:\n"));
13482                       display_raw_attribute (p, end);
13483                       p = end;
13484                     }
13485                   else
13486                     attr_len = 0;
13487                 }
13488             }
13489         }
13490       else
13491         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13492
13493       free (contents);
13494     }
13495   return 1;
13496 }
13497
13498 static int
13499 process_arm_specific (FILE * file)
13500 {
13501   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13502                              display_arm_attribute, NULL);
13503 }
13504
13505 static int
13506 process_power_specific (FILE * file)
13507 {
13508   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13509                              display_power_gnu_attribute);
13510 }
13511
13512 static int
13513 process_sparc_specific (FILE * file)
13514 {
13515   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13516                              display_sparc_gnu_attribute);
13517 }
13518
13519 static int
13520 process_tic6x_specific (FILE * file)
13521 {
13522   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13523                              display_tic6x_attribute, NULL);
13524 }
13525
13526 static int
13527 process_msp430x_specific (FILE * file)
13528 {
13529   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13530                              display_msp430x_attribute, NULL);
13531 }
13532
13533 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13534    Print the Address, Access and Initial fields of an entry at VMA ADDR
13535    and return the VMA of the next entry, or -1 if there was a problem.
13536    Does not read from DATA_END or beyond.  */
13537
13538 static bfd_vma
13539 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13540                       unsigned char * data_end)
13541 {
13542   printf ("  ");
13543   print_vma (addr, LONG_HEX);
13544   printf (" ");
13545   if (addr < pltgot + 0xfff0)
13546     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13547   else
13548     printf ("%10s", "");
13549   printf (" ");
13550   if (data == NULL)
13551     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13552   else
13553     {
13554       bfd_vma entry;
13555       unsigned char * from = data + addr - pltgot;
13556
13557       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13558         {
13559           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13560           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13561           return (bfd_vma) -1;
13562         }
13563       else
13564         {
13565           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13566           print_vma (entry, LONG_HEX);
13567         }
13568     }
13569   return addr + (is_32bit_elf ? 4 : 8);
13570 }
13571
13572 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13573    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13574    ADDR and return the VMA of the next entry.  */
13575
13576 static bfd_vma
13577 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13578 {
13579   printf ("  ");
13580   print_vma (addr, LONG_HEX);
13581   printf (" ");
13582   if (data == NULL)
13583     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13584   else
13585     {
13586       bfd_vma entry;
13587
13588       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13589       print_vma (entry, LONG_HEX);
13590     }
13591   return addr + (is_32bit_elf ? 4 : 8);
13592 }
13593
13594 static void
13595 print_mips_ases (unsigned int mask)
13596 {
13597   if (mask & AFL_ASE_DSP)
13598     fputs ("\n\tDSP ASE", stdout);
13599   if (mask & AFL_ASE_DSPR2)
13600     fputs ("\n\tDSP R2 ASE", stdout);
13601   if (mask & AFL_ASE_EVA)
13602     fputs ("\n\tEnhanced VA Scheme", stdout);
13603   if (mask & AFL_ASE_MCU)
13604     fputs ("\n\tMCU (MicroController) ASE", stdout);
13605   if (mask & AFL_ASE_MDMX)
13606     fputs ("\n\tMDMX ASE", stdout);
13607   if (mask & AFL_ASE_MIPS3D)
13608     fputs ("\n\tMIPS-3D ASE", stdout);
13609   if (mask & AFL_ASE_MT)
13610     fputs ("\n\tMT ASE", stdout);
13611   if (mask & AFL_ASE_SMARTMIPS)
13612     fputs ("\n\tSmartMIPS ASE", stdout);
13613   if (mask & AFL_ASE_VIRT)
13614     fputs ("\n\tVZ ASE", stdout);
13615   if (mask & AFL_ASE_MSA)
13616     fputs ("\n\tMSA ASE", stdout);
13617   if (mask & AFL_ASE_MIPS16)
13618     fputs ("\n\tMIPS16 ASE", stdout);
13619   if (mask & AFL_ASE_MICROMIPS)
13620     fputs ("\n\tMICROMIPS ASE", stdout);
13621   if (mask & AFL_ASE_XPA)
13622     fputs ("\n\tXPA ASE", stdout);
13623   if (mask == 0)
13624     fprintf (stdout, "\n\t%s", _("None"));
13625   else if ((mask & ~AFL_ASE_MASK) != 0)
13626     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13627 }
13628
13629 static void
13630 print_mips_isa_ext (unsigned int isa_ext)
13631 {
13632   switch (isa_ext)
13633     {
13634     case 0:
13635       fputs (_("None"), stdout);
13636       break;
13637     case AFL_EXT_XLR:
13638       fputs ("RMI XLR", stdout);
13639       break;
13640     case AFL_EXT_OCTEON3:
13641       fputs ("Cavium Networks Octeon3", stdout);
13642       break;
13643     case AFL_EXT_OCTEON2:
13644       fputs ("Cavium Networks Octeon2", stdout);
13645       break;
13646     case AFL_EXT_OCTEONP:
13647       fputs ("Cavium Networks OcteonP", stdout);
13648       break;
13649     case AFL_EXT_LOONGSON_3A:
13650       fputs ("Loongson 3A", stdout);
13651       break;
13652     case AFL_EXT_OCTEON:
13653       fputs ("Cavium Networks Octeon", stdout);
13654       break;
13655     case AFL_EXT_5900:
13656       fputs ("Toshiba R5900", stdout);
13657       break;
13658     case AFL_EXT_4650:
13659       fputs ("MIPS R4650", stdout);
13660       break;
13661     case AFL_EXT_4010:
13662       fputs ("LSI R4010", stdout);
13663       break;
13664     case AFL_EXT_4100:
13665       fputs ("NEC VR4100", stdout);
13666       break;
13667     case AFL_EXT_3900:
13668       fputs ("Toshiba R3900", stdout);
13669       break;
13670     case AFL_EXT_10000:
13671       fputs ("MIPS R10000", stdout);
13672       break;
13673     case AFL_EXT_SB1:
13674       fputs ("Broadcom SB-1", stdout);
13675       break;
13676     case AFL_EXT_4111:
13677       fputs ("NEC VR4111/VR4181", stdout);
13678       break;
13679     case AFL_EXT_4120:
13680       fputs ("NEC VR4120", stdout);
13681       break;
13682     case AFL_EXT_5400:
13683       fputs ("NEC VR5400", stdout);
13684       break;
13685     case AFL_EXT_5500:
13686       fputs ("NEC VR5500", stdout);
13687       break;
13688     case AFL_EXT_LOONGSON_2E:
13689       fputs ("ST Microelectronics Loongson 2E", stdout);
13690       break;
13691     case AFL_EXT_LOONGSON_2F:
13692       fputs ("ST Microelectronics Loongson 2F", stdout);
13693       break;
13694     default:
13695       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13696     }
13697 }
13698
13699 static int
13700 get_mips_reg_size (int reg_size)
13701 {
13702   return (reg_size == AFL_REG_NONE) ? 0
13703          : (reg_size == AFL_REG_32) ? 32
13704          : (reg_size == AFL_REG_64) ? 64
13705          : (reg_size == AFL_REG_128) ? 128
13706          : -1;
13707 }
13708
13709 static int
13710 process_mips_specific (FILE * file)
13711 {
13712   Elf_Internal_Dyn * entry;
13713   Elf_Internal_Shdr *sect = NULL;
13714   size_t liblist_offset = 0;
13715   size_t liblistno = 0;
13716   size_t conflictsno = 0;
13717   size_t options_offset = 0;
13718   size_t conflicts_offset = 0;
13719   size_t pltrelsz = 0;
13720   size_t pltrel = 0;
13721   bfd_vma pltgot = 0;
13722   bfd_vma mips_pltgot = 0;
13723   bfd_vma jmprel = 0;
13724   bfd_vma local_gotno = 0;
13725   bfd_vma gotsym = 0;
13726   bfd_vma symtabno = 0;
13727
13728   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13729                       display_mips_gnu_attribute);
13730
13731   sect = find_section (".MIPS.abiflags");
13732
13733   if (sect != NULL)
13734     {
13735       Elf_External_ABIFlags_v0 *abiflags_ext;
13736       Elf_Internal_ABIFlags_v0 abiflags_in;
13737
13738       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13739         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13740       else
13741         {
13742           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13743                                    sect->sh_size, _("MIPS ABI Flags section"));
13744           if (abiflags_ext)
13745             {
13746               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13747               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13748               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13749               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13750               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13751               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13752               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13753               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13754               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13755               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13756               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13757
13758               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13759               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13760               if (abiflags_in.isa_rev > 1)
13761                 printf ("r%d", abiflags_in.isa_rev);
13762               printf ("\nGPR size: %d",
13763                       get_mips_reg_size (abiflags_in.gpr_size));
13764               printf ("\nCPR1 size: %d",
13765                       get_mips_reg_size (abiflags_in.cpr1_size));
13766               printf ("\nCPR2 size: %d",
13767                       get_mips_reg_size (abiflags_in.cpr2_size));
13768               fputs ("\nFP ABI: ", stdout);
13769               print_mips_fp_abi_value (abiflags_in.fp_abi);
13770               fputs ("ISA Extension: ", stdout);
13771               print_mips_isa_ext (abiflags_in.isa_ext);
13772               fputs ("\nASEs:", stdout);
13773               print_mips_ases (abiflags_in.ases);
13774               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13775               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13776               fputc ('\n', stdout);
13777               free (abiflags_ext);
13778             }
13779         }
13780     }
13781
13782   /* We have a lot of special sections.  Thanks SGI!  */
13783   if (dynamic_section == NULL)
13784     /* No information available.  */
13785     return 0;
13786
13787   for (entry = dynamic_section;
13788        /* PR 17531 file: 012-50589-0.004.  */
13789        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13790        ++entry)
13791     switch (entry->d_tag)
13792       {
13793       case DT_MIPS_LIBLIST:
13794         liblist_offset
13795           = offset_from_vma (file, entry->d_un.d_val,
13796                              liblistno * sizeof (Elf32_External_Lib));
13797         break;
13798       case DT_MIPS_LIBLISTNO:
13799         liblistno = entry->d_un.d_val;
13800         break;
13801       case DT_MIPS_OPTIONS:
13802         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13803         break;
13804       case DT_MIPS_CONFLICT:
13805         conflicts_offset
13806           = offset_from_vma (file, entry->d_un.d_val,
13807                              conflictsno * sizeof (Elf32_External_Conflict));
13808         break;
13809       case DT_MIPS_CONFLICTNO:
13810         conflictsno = entry->d_un.d_val;
13811         break;
13812       case DT_PLTGOT:
13813         pltgot = entry->d_un.d_ptr;
13814         break;
13815       case DT_MIPS_LOCAL_GOTNO:
13816         local_gotno = entry->d_un.d_val;
13817         break;
13818       case DT_MIPS_GOTSYM:
13819         gotsym = entry->d_un.d_val;
13820         break;
13821       case DT_MIPS_SYMTABNO:
13822         symtabno = entry->d_un.d_val;
13823         break;
13824       case DT_MIPS_PLTGOT:
13825         mips_pltgot = entry->d_un.d_ptr;
13826         break;
13827       case DT_PLTREL:
13828         pltrel = entry->d_un.d_val;
13829         break;
13830       case DT_PLTRELSZ:
13831         pltrelsz = entry->d_un.d_val;
13832         break;
13833       case DT_JMPREL:
13834         jmprel = entry->d_un.d_ptr;
13835         break;
13836       default:
13837         break;
13838       }
13839
13840   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13841     {
13842       Elf32_External_Lib * elib;
13843       size_t cnt;
13844
13845       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13846                                               liblistno,
13847                                               sizeof (Elf32_External_Lib),
13848                                               _("liblist section data"));
13849       if (elib)
13850         {
13851           printf (_("\nSection '.liblist' contains %lu entries:\n"),
13852                   (unsigned long) liblistno);
13853           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
13854                  stdout);
13855
13856           for (cnt = 0; cnt < liblistno; ++cnt)
13857             {
13858               Elf32_Lib liblist;
13859               time_t atime;
13860               char timebuf[20];
13861               struct tm * tmp;
13862
13863               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13864               atime = BYTE_GET (elib[cnt].l_time_stamp);
13865               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13866               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13867               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13868
13869               tmp = gmtime (&atime);
13870               snprintf (timebuf, sizeof (timebuf),
13871                         "%04u-%02u-%02uT%02u:%02u:%02u",
13872                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13873                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13874
13875               printf ("%3lu: ", (unsigned long) cnt);
13876               if (VALID_DYNAMIC_NAME (liblist.l_name))
13877                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13878               else
13879                 printf (_("<corrupt: %9ld>"), liblist.l_name);
13880               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13881                       liblist.l_version);
13882
13883               if (liblist.l_flags == 0)
13884                 puts (_(" NONE"));
13885               else
13886                 {
13887                   static const struct
13888                   {
13889                     const char * name;
13890                     int bit;
13891                   }
13892                   l_flags_vals[] =
13893                   {
13894                     { " EXACT_MATCH", LL_EXACT_MATCH },
13895                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13896                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13897                     { " EXPORTS", LL_EXPORTS },
13898                     { " DELAY_LOAD", LL_DELAY_LOAD },
13899                     { " DELTA", LL_DELTA }
13900                   };
13901                   int flags = liblist.l_flags;
13902                   size_t fcnt;
13903
13904                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13905                     if ((flags & l_flags_vals[fcnt].bit) != 0)
13906                       {
13907                         fputs (l_flags_vals[fcnt].name, stdout);
13908                         flags ^= l_flags_vals[fcnt].bit;
13909                       }
13910                   if (flags != 0)
13911                     printf (" %#x", (unsigned int) flags);
13912
13913                   puts ("");
13914                 }
13915             }
13916
13917           free (elib);
13918         }
13919     }
13920
13921   if (options_offset != 0)
13922     {
13923       Elf_External_Options * eopt;
13924       Elf_Internal_Options * iopt;
13925       Elf_Internal_Options * option;
13926       size_t offset;
13927       int cnt;
13928       sect = section_headers;
13929
13930       /* Find the section header so that we get the size.  */
13931       sect = find_section_by_type (SHT_MIPS_OPTIONS);
13932       /* PR 17533 file: 012-277276-0.004.  */
13933       if (sect == NULL)
13934         {
13935           error (_("No MIPS_OPTIONS header found\n"));
13936           return 0;
13937         }
13938
13939       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13940                                                 sect->sh_size, _("options"));
13941       if (eopt)
13942         {
13943           iopt = (Elf_Internal_Options *)
13944               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13945           if (iopt == NULL)
13946             {
13947               error (_("Out of memory allocatinf space for MIPS options\n"));
13948               return 0;
13949             }
13950
13951           offset = cnt = 0;
13952           option = iopt;
13953
13954           while (offset <= sect->sh_size - sizeof (* eopt))
13955             {
13956               Elf_External_Options * eoption;
13957
13958               eoption = (Elf_External_Options *) ((char *) eopt + offset);
13959
13960               option->kind = BYTE_GET (eoption->kind);
13961               option->size = BYTE_GET (eoption->size);
13962               option->section = BYTE_GET (eoption->section);
13963               option->info = BYTE_GET (eoption->info);
13964
13965               /* PR 17531: file: ffa0fa3b.  */
13966               if (option->size < sizeof (* eopt)
13967                   || offset + option->size > sect->sh_size)
13968                 {
13969                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
13970                   return 0;
13971                 }
13972               offset += option->size;
13973
13974               ++option;
13975               ++cnt;
13976             }
13977
13978           printf (_("\nSection '%s' contains %d entries:\n"),
13979                   printable_section_name (sect), cnt);
13980
13981           option = iopt;
13982           offset = 0;
13983
13984           while (cnt-- > 0)
13985             {
13986               size_t len;
13987
13988               switch (option->kind)
13989                 {
13990                 case ODK_NULL:
13991                   /* This shouldn't happen.  */
13992                   printf (" NULL       %d %lx", option->section, option->info);
13993                   break;
13994                 case ODK_REGINFO:
13995                   printf (" REGINFO    ");
13996                   if (elf_header.e_machine == EM_MIPS)
13997                     {
13998                       /* 32bit form.  */
13999                       Elf32_External_RegInfo * ereg;
14000                       Elf32_RegInfo reginfo;
14001
14002                       ereg = (Elf32_External_RegInfo *) (option + 1);
14003                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14004                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14005                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14006                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14007                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14008                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14009
14010                       printf ("GPR %08lx  GP 0x%lx\n",
14011                               reginfo.ri_gprmask,
14012                               (unsigned long) reginfo.ri_gp_value);
14013                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14014                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14015                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14016                     }
14017                   else
14018                     {
14019                       /* 64 bit form.  */
14020                       Elf64_External_RegInfo * ereg;
14021                       Elf64_Internal_RegInfo reginfo;
14022
14023                       ereg = (Elf64_External_RegInfo *) (option + 1);
14024                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14025                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14026                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14027                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14028                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14029                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14030
14031                       printf ("GPR %08lx  GP 0x",
14032                               reginfo.ri_gprmask);
14033                       printf_vma (reginfo.ri_gp_value);
14034                       printf ("\n");
14035
14036                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14037                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14038                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14039                     }
14040                   ++option;
14041                   continue;
14042                 case ODK_EXCEPTIONS:
14043                   fputs (" EXCEPTIONS fpe_min(", stdout);
14044                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14045                   fputs (") fpe_max(", stdout);
14046                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14047                   fputs (")", stdout);
14048
14049                   if (option->info & OEX_PAGE0)
14050                     fputs (" PAGE0", stdout);
14051                   if (option->info & OEX_SMM)
14052                     fputs (" SMM", stdout);
14053                   if (option->info & OEX_FPDBUG)
14054                     fputs (" FPDBUG", stdout);
14055                   if (option->info & OEX_DISMISS)
14056                     fputs (" DISMISS", stdout);
14057                   break;
14058                 case ODK_PAD:
14059                   fputs (" PAD       ", stdout);
14060                   if (option->info & OPAD_PREFIX)
14061                     fputs (" PREFIX", stdout);
14062                   if (option->info & OPAD_POSTFIX)
14063                     fputs (" POSTFIX", stdout);
14064                   if (option->info & OPAD_SYMBOL)
14065                     fputs (" SYMBOL", stdout);
14066                   break;
14067                 case ODK_HWPATCH:
14068                   fputs (" HWPATCH   ", stdout);
14069                   if (option->info & OHW_R4KEOP)
14070                     fputs (" R4KEOP", stdout);
14071                   if (option->info & OHW_R8KPFETCH)
14072                     fputs (" R8KPFETCH", stdout);
14073                   if (option->info & OHW_R5KEOP)
14074                     fputs (" R5KEOP", stdout);
14075                   if (option->info & OHW_R5KCVTL)
14076                     fputs (" R5KCVTL", stdout);
14077                   break;
14078                 case ODK_FILL:
14079                   fputs (" FILL       ", stdout);
14080                   /* XXX Print content of info word?  */
14081                   break;
14082                 case ODK_TAGS:
14083                   fputs (" TAGS       ", stdout);
14084                   /* XXX Print content of info word?  */
14085                   break;
14086                 case ODK_HWAND:
14087                   fputs (" HWAND     ", stdout);
14088                   if (option->info & OHWA0_R4KEOP_CHECKED)
14089                     fputs (" R4KEOP_CHECKED", stdout);
14090                   if (option->info & OHWA0_R4KEOP_CLEAN)
14091                     fputs (" R4KEOP_CLEAN", stdout);
14092                   break;
14093                 case ODK_HWOR:
14094                   fputs (" HWOR      ", stdout);
14095                   if (option->info & OHWA0_R4KEOP_CHECKED)
14096                     fputs (" R4KEOP_CHECKED", stdout);
14097                   if (option->info & OHWA0_R4KEOP_CLEAN)
14098                     fputs (" R4KEOP_CLEAN", stdout);
14099                   break;
14100                 case ODK_GP_GROUP:
14101                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14102                           option->info & OGP_GROUP,
14103                           (option->info & OGP_SELF) >> 16);
14104                   break;
14105                 case ODK_IDENT:
14106                   printf (" IDENT     %#06lx  self-contained %#06lx",
14107                           option->info & OGP_GROUP,
14108                           (option->info & OGP_SELF) >> 16);
14109                   break;
14110                 default:
14111                   /* This shouldn't happen.  */
14112                   printf (" %3d ???     %d %lx",
14113                           option->kind, option->section, option->info);
14114                   break;
14115                 }
14116
14117               len = sizeof (* eopt);
14118               while (len < option->size)
14119                 {
14120                   char datum = * ((char *) eopt + offset + len);
14121
14122                   if (ISPRINT (datum))
14123                     printf ("%c", datum);
14124                   else
14125                     printf ("\\%03o", datum);
14126                   len ++;
14127                 }
14128               fputs ("\n", stdout);
14129
14130               offset += option->size;
14131               ++option;
14132             }
14133
14134           free (eopt);
14135         }
14136     }
14137
14138   if (conflicts_offset != 0 && conflictsno != 0)
14139     {
14140       Elf32_Conflict * iconf;
14141       size_t cnt;
14142
14143       if (dynamic_symbols == NULL)
14144         {
14145           error (_("conflict list found without a dynamic symbol table\n"));
14146           return 0;
14147         }
14148
14149       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14150       if (iconf == NULL)
14151         {
14152           error (_("Out of memory allocating space for dynamic conflicts\n"));
14153           return 0;
14154         }
14155
14156       if (is_32bit_elf)
14157         {
14158           Elf32_External_Conflict * econf32;
14159
14160           econf32 = (Elf32_External_Conflict *)
14161               get_data (NULL, file, conflicts_offset, conflictsno,
14162                         sizeof (* econf32), _("conflict"));
14163           if (!econf32)
14164             return 0;
14165
14166           for (cnt = 0; cnt < conflictsno; ++cnt)
14167             iconf[cnt] = BYTE_GET (econf32[cnt]);
14168
14169           free (econf32);
14170         }
14171       else
14172         {
14173           Elf64_External_Conflict * econf64;
14174
14175           econf64 = (Elf64_External_Conflict *)
14176               get_data (NULL, file, conflicts_offset, conflictsno,
14177                         sizeof (* econf64), _("conflict"));
14178           if (!econf64)
14179             return 0;
14180
14181           for (cnt = 0; cnt < conflictsno; ++cnt)
14182             iconf[cnt] = BYTE_GET (econf64[cnt]);
14183
14184           free (econf64);
14185         }
14186
14187       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14188               (unsigned long) conflictsno);
14189       puts (_("  Num:    Index       Value  Name"));
14190
14191       for (cnt = 0; cnt < conflictsno; ++cnt)
14192         {
14193           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14194
14195           if (iconf[cnt] >= num_dynamic_syms)
14196             printf (_("<corrupt symbol index>"));
14197           else
14198             {
14199               Elf_Internal_Sym * psym;
14200
14201               psym = & dynamic_symbols[iconf[cnt]];
14202               print_vma (psym->st_value, FULL_HEX);
14203               putchar (' ');
14204               if (VALID_DYNAMIC_NAME (psym->st_name))
14205                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14206               else
14207                 printf (_("<corrupt: %14ld>"), psym->st_name);
14208             }
14209           putchar ('\n');
14210         }
14211
14212       free (iconf);
14213     }
14214
14215   if (pltgot != 0 && local_gotno != 0)
14216     {
14217       bfd_vma ent, local_end, global_end;
14218       size_t i, offset;
14219       unsigned char * data;
14220       unsigned char * data_end;
14221       int addr_size;
14222
14223       ent = pltgot;
14224       addr_size = (is_32bit_elf ? 4 : 8);
14225       local_end = pltgot + local_gotno * addr_size;
14226
14227       /* PR binutils/17533 file: 012-111227-0.004  */
14228       if (symtabno < gotsym)
14229         {
14230           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14231                  (unsigned long) gotsym, (unsigned long) symtabno);
14232           return 0;
14233         }
14234
14235       global_end = local_end + (symtabno - gotsym) * addr_size;
14236       /* PR 17531: file: 54c91a34.  */
14237       if (global_end < local_end)
14238         {
14239           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14240           return 0;
14241         }
14242
14243       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14244       data = (unsigned char *) get_data (NULL, file, offset,
14245                                          global_end - pltgot, 1,
14246                                          _("Global Offset Table data"));
14247       if (data == NULL)
14248         return 0;
14249       data_end = data + (global_end - pltgot);
14250
14251       printf (_("\nPrimary GOT:\n"));
14252       printf (_(" Canonical gp value: "));
14253       print_vma (pltgot + 0x7ff0, LONG_HEX);
14254       printf ("\n\n");
14255
14256       printf (_(" Reserved entries:\n"));
14257       printf (_("  %*s %10s %*s Purpose\n"),
14258               addr_size * 2, _("Address"), _("Access"),
14259               addr_size * 2, _("Initial"));
14260       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14261       printf (_(" Lazy resolver\n"));
14262       if (ent == (bfd_vma) -1)
14263         goto got_print_fail;
14264       if (data
14265           && (byte_get (data + ent - pltgot, addr_size)
14266               >> (addr_size * 8 - 1)) != 0)
14267         {
14268           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14269           printf (_(" Module pointer (GNU extension)\n"));
14270           if (ent == (bfd_vma) -1)
14271             goto got_print_fail;
14272         }
14273       printf ("\n");
14274
14275       if (ent < local_end)
14276         {
14277           printf (_(" Local entries:\n"));
14278           printf ("  %*s %10s %*s\n",
14279                   addr_size * 2, _("Address"), _("Access"),
14280                   addr_size * 2, _("Initial"));
14281           while (ent < local_end)
14282             {
14283               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14284               printf ("\n");
14285               if (ent == (bfd_vma) -1)
14286                 goto got_print_fail;
14287             }
14288           printf ("\n");
14289         }
14290
14291       if (gotsym < symtabno)
14292         {
14293           int sym_width;
14294
14295           printf (_(" Global entries:\n"));
14296           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14297                   addr_size * 2, _("Address"),
14298                   _("Access"),
14299                   addr_size * 2, _("Initial"),
14300                   addr_size * 2, _("Sym.Val."),
14301                   _("Type"),
14302                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14303                   _("Ndx"), _("Name"));
14304
14305           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14306
14307           for (i = gotsym; i < symtabno; i++)
14308             {
14309               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14310               printf (" ");
14311
14312               if (dynamic_symbols == NULL)
14313                 printf (_("<no dynamic symbols>"));
14314               else if (i < num_dynamic_syms)
14315                 {
14316                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14317
14318                   print_vma (psym->st_value, LONG_HEX);
14319                   printf (" %-7s %3s ",
14320                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14321                           get_symbol_index_type (psym->st_shndx));
14322
14323                   if (VALID_DYNAMIC_NAME (psym->st_name))
14324                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14325                   else
14326                     printf (_("<corrupt: %14ld>"), psym->st_name);
14327                 }
14328               else
14329                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14330                         (unsigned long) i);
14331
14332               printf ("\n");
14333               if (ent == (bfd_vma) -1)
14334                 break;
14335             }
14336           printf ("\n");
14337         }
14338
14339     got_print_fail:
14340       if (data)
14341         free (data);
14342     }
14343
14344   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14345     {
14346       bfd_vma ent, end;
14347       size_t offset, rel_offset;
14348       unsigned long count, i;
14349       unsigned char * data;
14350       int addr_size, sym_width;
14351       Elf_Internal_Rela * rels;
14352
14353       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14354       if (pltrel == DT_RELA)
14355         {
14356           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14357             return 0;
14358         }
14359       else
14360         {
14361           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14362             return 0;
14363         }
14364
14365       ent = mips_pltgot;
14366       addr_size = (is_32bit_elf ? 4 : 8);
14367       end = mips_pltgot + (2 + count) * addr_size;
14368
14369       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14370       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14371                                          1, _("Procedure Linkage Table data"));
14372       if (data == NULL)
14373         return 0;
14374
14375       printf ("\nPLT GOT:\n\n");
14376       printf (_(" Reserved entries:\n"));
14377       printf (_("  %*s %*s Purpose\n"),
14378               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14379       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14380       printf (_(" PLT lazy resolver\n"));
14381       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14382       printf (_(" Module pointer\n"));
14383       printf ("\n");
14384
14385       printf (_(" Entries:\n"));
14386       printf ("  %*s %*s %*s %-7s %3s %s\n",
14387               addr_size * 2, _("Address"),
14388               addr_size * 2, _("Initial"),
14389               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14390       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14391       for (i = 0; i < count; i++)
14392         {
14393           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14394
14395           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14396           printf (" ");
14397
14398           if (idx >= num_dynamic_syms)
14399             printf (_("<corrupt symbol index: %lu>"), idx);
14400           else
14401             {
14402               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14403
14404               print_vma (psym->st_value, LONG_HEX);
14405               printf (" %-7s %3s ",
14406                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14407                       get_symbol_index_type (psym->st_shndx));
14408               if (VALID_DYNAMIC_NAME (psym->st_name))
14409                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14410               else
14411                 printf (_("<corrupt: %14ld>"), psym->st_name);
14412             }
14413           printf ("\n");
14414         }
14415       printf ("\n");
14416
14417       if (data)
14418         free (data);
14419       free (rels);
14420     }
14421
14422   return 1;
14423 }
14424
14425 static int
14426 process_nds32_specific (FILE * file)
14427 {
14428   Elf_Internal_Shdr *sect = NULL;
14429
14430   sect = find_section (".nds32_e_flags");
14431   if (sect != NULL)
14432     {
14433       unsigned int *flag;
14434
14435       printf ("\nNDS32 elf flags section:\n");
14436       flag = get_data (NULL, file, sect->sh_offset, 1,
14437                        sect->sh_size, _("NDS32 elf flags section"));
14438
14439       switch ((*flag) & 0x3)
14440         {
14441         case 0:
14442           printf ("(VEC_SIZE):\tNo entry.\n");
14443           break;
14444         case 1:
14445           printf ("(VEC_SIZE):\t4 bytes\n");
14446           break;
14447         case 2:
14448           printf ("(VEC_SIZE):\t16 bytes\n");
14449           break;
14450         case 3:
14451           printf ("(VEC_SIZE):\treserved\n");
14452           break;
14453         }
14454     }
14455
14456   return TRUE;
14457 }
14458
14459 static int
14460 process_gnu_liblist (FILE * file)
14461 {
14462   Elf_Internal_Shdr * section;
14463   Elf_Internal_Shdr * string_sec;
14464   Elf32_External_Lib * elib;
14465   char * strtab;
14466   size_t strtab_size;
14467   size_t cnt;
14468   unsigned i;
14469
14470   if (! do_arch)
14471     return 0;
14472
14473   for (i = 0, section = section_headers;
14474        i < elf_header.e_shnum;
14475        i++, section++)
14476     {
14477       switch (section->sh_type)
14478         {
14479         case SHT_GNU_LIBLIST:
14480           if (section->sh_link >= elf_header.e_shnum)
14481             break;
14482
14483           elib = (Elf32_External_Lib *)
14484               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14485                         _("liblist section data"));
14486
14487           if (elib == NULL)
14488             break;
14489           string_sec = section_headers + section->sh_link;
14490
14491           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14492                                       string_sec->sh_size,
14493                                       _("liblist string table"));
14494           if (strtab == NULL
14495               || section->sh_entsize != sizeof (Elf32_External_Lib))
14496             {
14497               free (elib);
14498               free (strtab);
14499               break;
14500             }
14501           strtab_size = string_sec->sh_size;
14502
14503           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14504                   printable_section_name (section),
14505                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14506
14507           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14508
14509           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14510                ++cnt)
14511             {
14512               Elf32_Lib liblist;
14513               time_t atime;
14514               char timebuf[20];
14515               struct tm * tmp;
14516
14517               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14518               atime = BYTE_GET (elib[cnt].l_time_stamp);
14519               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14520               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14521               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14522
14523               tmp = gmtime (&atime);
14524               snprintf (timebuf, sizeof (timebuf),
14525                         "%04u-%02u-%02uT%02u:%02u:%02u",
14526                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14527                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14528
14529               printf ("%3lu: ", (unsigned long) cnt);
14530               if (do_wide)
14531                 printf ("%-20s", liblist.l_name < strtab_size
14532                         ? strtab + liblist.l_name : _("<corrupt>"));
14533               else
14534                 printf ("%-20.20s", liblist.l_name < strtab_size
14535                         ? strtab + liblist.l_name : _("<corrupt>"));
14536               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14537                       liblist.l_version, liblist.l_flags);
14538             }
14539
14540           free (elib);
14541           free (strtab);
14542         }
14543     }
14544
14545   return 1;
14546 }
14547
14548 static const char *
14549 get_note_type (unsigned e_type)
14550 {
14551   static char buff[64];
14552
14553   if (elf_header.e_type == ET_CORE)
14554     switch (e_type)
14555       {
14556       case NT_AUXV:
14557         return _("NT_AUXV (auxiliary vector)");
14558       case NT_PRSTATUS:
14559         return _("NT_PRSTATUS (prstatus structure)");
14560       case NT_FPREGSET:
14561         return _("NT_FPREGSET (floating point registers)");
14562       case NT_PRPSINFO:
14563         return _("NT_PRPSINFO (prpsinfo structure)");
14564       case NT_TASKSTRUCT:
14565         return _("NT_TASKSTRUCT (task structure)");
14566       case NT_PRXFPREG:
14567         return _("NT_PRXFPREG (user_xfpregs structure)");
14568       case NT_PPC_VMX:
14569         return _("NT_PPC_VMX (ppc Altivec registers)");
14570       case NT_PPC_VSX:
14571         return _("NT_PPC_VSX (ppc VSX registers)");
14572       case NT_386_TLS:
14573         return _("NT_386_TLS (x86 TLS information)");
14574       case NT_386_IOPERM:
14575         return _("NT_386_IOPERM (x86 I/O permissions)");
14576       case NT_X86_XSTATE:
14577         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14578       case NT_S390_HIGH_GPRS:
14579         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14580       case NT_S390_TIMER:
14581         return _("NT_S390_TIMER (s390 timer register)");
14582       case NT_S390_TODCMP:
14583         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14584       case NT_S390_TODPREG:
14585         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14586       case NT_S390_CTRS:
14587         return _("NT_S390_CTRS (s390 control registers)");
14588       case NT_S390_PREFIX:
14589         return _("NT_S390_PREFIX (s390 prefix register)");
14590       case NT_S390_LAST_BREAK:
14591         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14592       case NT_S390_SYSTEM_CALL:
14593         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14594       case NT_S390_TDB:
14595         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14596       case NT_S390_VXRS_LOW:
14597         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14598       case NT_S390_VXRS_HIGH:
14599         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14600       case NT_ARM_VFP:
14601         return _("NT_ARM_VFP (arm VFP registers)");
14602       case NT_ARM_TLS:
14603         return _("NT_ARM_TLS (AArch TLS registers)");
14604       case NT_ARM_HW_BREAK:
14605         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14606       case NT_ARM_HW_WATCH:
14607         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14608       case NT_PSTATUS:
14609         return _("NT_PSTATUS (pstatus structure)");
14610       case NT_FPREGS:
14611         return _("NT_FPREGS (floating point registers)");
14612       case NT_PSINFO:
14613         return _("NT_PSINFO (psinfo structure)");
14614       case NT_LWPSTATUS:
14615         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14616       case NT_LWPSINFO:
14617         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14618       case NT_WIN32PSTATUS:
14619         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14620       case NT_SIGINFO:
14621         return _("NT_SIGINFO (siginfo_t data)");
14622       case NT_FILE:
14623         return _("NT_FILE (mapped files)");
14624       default:
14625         break;
14626       }
14627   else
14628     switch (e_type)
14629       {
14630       case NT_VERSION:
14631         return _("NT_VERSION (version)");
14632       case NT_ARCH:
14633         return _("NT_ARCH (architecture)");
14634       default:
14635         break;
14636       }
14637
14638   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14639   return buff;
14640 }
14641
14642 static int
14643 print_core_note (Elf_Internal_Note *pnote)
14644 {
14645   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14646   bfd_vma count, page_size;
14647   unsigned char *descdata, *filenames, *descend;
14648
14649   if (pnote->type != NT_FILE)
14650     return 1;
14651
14652 #ifndef BFD64
14653   if (!is_32bit_elf)
14654     {
14655       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14656       /* Still "successful".  */
14657       return 1;
14658     }
14659 #endif
14660
14661   if (pnote->descsz < 2 * addr_size)
14662     {
14663       printf (_("    Malformed note - too short for header\n"));
14664       return 0;
14665     }
14666
14667   descdata = (unsigned char *) pnote->descdata;
14668   descend = descdata + pnote->descsz;
14669
14670   if (descdata[pnote->descsz - 1] != '\0')
14671     {
14672       printf (_("    Malformed note - does not end with \\0\n"));
14673       return 0;
14674     }
14675
14676   count = byte_get (descdata, addr_size);
14677   descdata += addr_size;
14678
14679   page_size = byte_get (descdata, addr_size);
14680   descdata += addr_size;
14681
14682   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14683     {
14684       printf (_("    Malformed note - too short for supplied file count\n"));
14685       return 0;
14686     }
14687
14688   printf (_("    Page size: "));
14689   print_vma (page_size, DEC);
14690   printf ("\n");
14691
14692   printf (_("    %*s%*s%*s\n"),
14693           (int) (2 + 2 * addr_size), _("Start"),
14694           (int) (4 + 2 * addr_size), _("End"),
14695           (int) (4 + 2 * addr_size), _("Page Offset"));
14696   filenames = descdata + count * 3 * addr_size;
14697   while (--count > 0)
14698     {
14699       bfd_vma start, end, file_ofs;
14700
14701       if (filenames == descend)
14702         {
14703           printf (_("    Malformed note - filenames end too early\n"));
14704           return 0;
14705         }
14706
14707       start = byte_get (descdata, addr_size);
14708       descdata += addr_size;
14709       end = byte_get (descdata, addr_size);
14710       descdata += addr_size;
14711       file_ofs = byte_get (descdata, addr_size);
14712       descdata += addr_size;
14713
14714       printf ("    ");
14715       print_vma (start, FULL_HEX);
14716       printf ("  ");
14717       print_vma (end, FULL_HEX);
14718       printf ("  ");
14719       print_vma (file_ofs, FULL_HEX);
14720       printf ("\n        %s\n", filenames);
14721
14722       filenames += 1 + strlen ((char *) filenames);
14723     }
14724
14725   return 1;
14726 }
14727
14728 static const char *
14729 get_gnu_elf_note_type (unsigned e_type)
14730 {
14731   static char buff[64];
14732
14733   switch (e_type)
14734     {
14735     case NT_GNU_ABI_TAG:
14736       return _("NT_GNU_ABI_TAG (ABI version tag)");
14737     case NT_GNU_HWCAP:
14738       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14739     case NT_GNU_BUILD_ID:
14740       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14741     case NT_GNU_GOLD_VERSION:
14742       return _("NT_GNU_GOLD_VERSION (gold version)");
14743     default:
14744       break;
14745     }
14746
14747   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14748   return buff;
14749 }
14750
14751 static int
14752 print_gnu_note (Elf_Internal_Note *pnote)
14753 {
14754   switch (pnote->type)
14755     {
14756     case NT_GNU_BUILD_ID:
14757       {
14758         unsigned long i;
14759
14760         printf (_("    Build ID: "));
14761         for (i = 0; i < pnote->descsz; ++i)
14762           printf ("%02x", pnote->descdata[i] & 0xff);
14763         printf ("\n");
14764       }
14765       break;
14766
14767     case NT_GNU_ABI_TAG:
14768       {
14769         unsigned long os, major, minor, subminor;
14770         const char *osname;
14771
14772         /* PR 17531: file: 030-599401-0.004.  */
14773         if (pnote->descsz < 16)
14774           {
14775             printf (_("    <corrupt GNU_ABI_TAG>\n"));
14776             break;
14777           }
14778
14779         os = byte_get ((unsigned char *) pnote->descdata, 4);
14780         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14781         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14782         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14783
14784         switch (os)
14785           {
14786           case GNU_ABI_TAG_LINUX:
14787             osname = "Linux";
14788             break;
14789           case GNU_ABI_TAG_HURD:
14790             osname = "Hurd";
14791             break;
14792           case GNU_ABI_TAG_SOLARIS:
14793             osname = "Solaris";
14794             break;
14795           case GNU_ABI_TAG_FREEBSD:
14796             osname = "FreeBSD";
14797             break;
14798           case GNU_ABI_TAG_NETBSD:
14799             osname = "NetBSD";
14800             break;
14801           default:
14802             osname = "Unknown";
14803             break;
14804           }
14805
14806         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14807                 major, minor, subminor);
14808       }
14809       break;
14810
14811     case NT_GNU_GOLD_VERSION:
14812       {
14813         unsigned long i;
14814
14815         printf (_("    Version: "));
14816         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14817           printf ("%c", pnote->descdata[i]);
14818         printf ("\n");
14819       }
14820       break;
14821     }
14822
14823   return 1;
14824 }
14825
14826 static const char *
14827 get_v850_elf_note_type (enum v850_notes n_type)
14828 {
14829   static char buff[64];
14830
14831   switch (n_type)
14832     {
14833     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
14834     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
14835     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
14836     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
14837     case V850_NOTE_CACHE_INFO: return _("Use of cache");
14838     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
14839     default:
14840       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14841       return buff;
14842     }
14843 }
14844
14845 static int
14846 print_v850_note (Elf_Internal_Note * pnote)
14847 {
14848   unsigned int val;
14849
14850   if (pnote->descsz != 4)
14851     return 0;
14852   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
14853
14854   if (val == 0)
14855     {
14856       printf (_("not set\n"));
14857       return 1;
14858     }
14859
14860   switch (pnote->type)
14861     {
14862     case V850_NOTE_ALIGNMENT:
14863       switch (val)
14864         {
14865         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
14866         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
14867         }
14868       break;
14869
14870     case V850_NOTE_DATA_SIZE:
14871       switch (val)
14872         {
14873         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
14874         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
14875         }
14876       break;
14877
14878     case V850_NOTE_FPU_INFO:
14879       switch (val)
14880         {
14881         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
14882         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
14883         }
14884       break;
14885
14886     case V850_NOTE_MMU_INFO:
14887     case V850_NOTE_CACHE_INFO:
14888     case V850_NOTE_SIMD_INFO:
14889       if (val == EF_RH850_SIMD)
14890         {
14891           printf (_("yes\n"));
14892           return 1;
14893         }
14894       break;
14895
14896     default:
14897       /* An 'unknown note type' message will already have been displayed.  */
14898       break;
14899     }
14900
14901   printf (_("unknown value: %x\n"), val);
14902   return 0;
14903 }
14904
14905 static const char *
14906 get_netbsd_elfcore_note_type (unsigned e_type)
14907 {
14908   static char buff[64];
14909
14910   if (e_type == NT_NETBSDCORE_PROCINFO)
14911     {
14912       /* NetBSD core "procinfo" structure.  */
14913       return _("NetBSD procinfo structure");
14914     }
14915
14916   /* As of Jan 2002 there are no other machine-independent notes
14917      defined for NetBSD core files.  If the note type is less
14918      than the start of the machine-dependent note types, we don't
14919      understand it.  */
14920
14921   if (e_type < NT_NETBSDCORE_FIRSTMACH)
14922     {
14923       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14924       return buff;
14925     }
14926
14927   switch (elf_header.e_machine)
14928     {
14929     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14930        and PT_GETFPREGS == mach+2.  */
14931
14932     case EM_OLD_ALPHA:
14933     case EM_ALPHA:
14934     case EM_SPARC:
14935     case EM_SPARC32PLUS:
14936     case EM_SPARCV9:
14937       switch (e_type)
14938         {
14939         case NT_NETBSDCORE_FIRSTMACH + 0:
14940           return _("PT_GETREGS (reg structure)");
14941         case NT_NETBSDCORE_FIRSTMACH + 2:
14942           return _("PT_GETFPREGS (fpreg structure)");
14943         default:
14944           break;
14945         }
14946       break;
14947
14948     /* On all other arch's, PT_GETREGS == mach+1 and
14949        PT_GETFPREGS == mach+3.  */
14950     default:
14951       switch (e_type)
14952         {
14953         case NT_NETBSDCORE_FIRSTMACH + 1:
14954           return _("PT_GETREGS (reg structure)");
14955         case NT_NETBSDCORE_FIRSTMACH + 3:
14956           return _("PT_GETFPREGS (fpreg structure)");
14957         default:
14958           break;
14959         }
14960     }
14961
14962   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14963             e_type - NT_NETBSDCORE_FIRSTMACH);
14964   return buff;
14965 }
14966
14967 static const char *
14968 get_stapsdt_note_type (unsigned e_type)
14969 {
14970   static char buff[64];
14971
14972   switch (e_type)
14973     {
14974     case NT_STAPSDT:
14975       return _("NT_STAPSDT (SystemTap probe descriptors)");
14976
14977     default:
14978       break;
14979     }
14980
14981   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14982   return buff;
14983 }
14984
14985 static int
14986 print_stapsdt_note (Elf_Internal_Note *pnote)
14987 {
14988   int addr_size = is_32bit_elf ? 4 : 8;
14989   char *data = pnote->descdata;
14990   char *data_end = pnote->descdata + pnote->descsz;
14991   bfd_vma pc, base_addr, semaphore;
14992   char *provider, *probe, *arg_fmt;
14993
14994   pc = byte_get ((unsigned char *) data, addr_size);
14995   data += addr_size;
14996   base_addr = byte_get ((unsigned char *) data, addr_size);
14997   data += addr_size;
14998   semaphore = byte_get ((unsigned char *) data, addr_size);
14999   data += addr_size;
15000
15001   provider = data;
15002   data += strlen (data) + 1;
15003   probe = data;
15004   data += strlen (data) + 1;
15005   arg_fmt = data;
15006   data += strlen (data) + 1;
15007
15008   printf (_("    Provider: %s\n"), provider);
15009   printf (_("    Name: %s\n"), probe);
15010   printf (_("    Location: "));
15011   print_vma (pc, FULL_HEX);
15012   printf (_(", Base: "));
15013   print_vma (base_addr, FULL_HEX);
15014   printf (_(", Semaphore: "));
15015   print_vma (semaphore, FULL_HEX);
15016   printf ("\n");
15017   printf (_("    Arguments: %s\n"), arg_fmt);
15018
15019   return data == data_end;
15020 }
15021
15022 static const char *
15023 get_ia64_vms_note_type (unsigned e_type)
15024 {
15025   static char buff[64];
15026
15027   switch (e_type)
15028     {
15029     case NT_VMS_MHD:
15030       return _("NT_VMS_MHD (module header)");
15031     case NT_VMS_LNM:
15032       return _("NT_VMS_LNM (language name)");
15033     case NT_VMS_SRC:
15034       return _("NT_VMS_SRC (source files)");
15035     case NT_VMS_TITLE:
15036       return "NT_VMS_TITLE";
15037     case NT_VMS_EIDC:
15038       return _("NT_VMS_EIDC (consistency check)");
15039     case NT_VMS_FPMODE:
15040       return _("NT_VMS_FPMODE (FP mode)");
15041     case NT_VMS_LINKTIME:
15042       return "NT_VMS_LINKTIME";
15043     case NT_VMS_IMGNAM:
15044       return _("NT_VMS_IMGNAM (image name)");
15045     case NT_VMS_IMGID:
15046       return _("NT_VMS_IMGID (image id)");
15047     case NT_VMS_LINKID:
15048       return _("NT_VMS_LINKID (link id)");
15049     case NT_VMS_IMGBID:
15050       return _("NT_VMS_IMGBID (build id)");
15051     case NT_VMS_GSTNAM:
15052       return _("NT_VMS_GSTNAM (sym table name)");
15053     case NT_VMS_ORIG_DYN:
15054       return "NT_VMS_ORIG_DYN";
15055     case NT_VMS_PATCHTIME:
15056       return "NT_VMS_PATCHTIME";
15057     default:
15058       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15059       return buff;
15060     }
15061 }
15062
15063 static int
15064 print_ia64_vms_note (Elf_Internal_Note * pnote)
15065 {
15066   switch (pnote->type)
15067     {
15068     case NT_VMS_MHD:
15069       if (pnote->descsz > 36)
15070         {
15071           size_t l = strlen (pnote->descdata + 34);
15072           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15073           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15074           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15075           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15076         }
15077       else
15078         printf (_("    Invalid size\n"));
15079       break;
15080     case NT_VMS_LNM:
15081       printf (_("   Language: %s\n"), pnote->descdata);
15082       break;
15083 #ifdef BFD64
15084     case NT_VMS_FPMODE:
15085       printf (_("   Floating Point mode: "));
15086       printf ("0x%016" BFD_VMA_FMT "x\n",
15087               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15088       break;
15089     case NT_VMS_LINKTIME:
15090       printf (_("   Link time: "));
15091       print_vms_time
15092         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15093       printf ("\n");
15094       break;
15095     case NT_VMS_PATCHTIME:
15096       printf (_("   Patch time: "));
15097       print_vms_time
15098         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15099       printf ("\n");
15100       break;
15101     case NT_VMS_ORIG_DYN:
15102       printf (_("   Major id: %u,  minor id: %u\n"),
15103               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15104               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15105       printf (_("   Last modified  : "));
15106       print_vms_time
15107         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15108       printf (_("\n   Link flags  : "));
15109       printf ("0x%016" BFD_VMA_FMT "x\n",
15110               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15111       printf (_("   Header flags: 0x%08x\n"),
15112               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15113       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15114       break;
15115 #endif
15116     case NT_VMS_IMGNAM:
15117       printf (_("    Image name: %s\n"), pnote->descdata);
15118       break;
15119     case NT_VMS_GSTNAM:
15120       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15121       break;
15122     case NT_VMS_IMGID:
15123       printf (_("    Image id: %s\n"), pnote->descdata);
15124       break;
15125     case NT_VMS_LINKID:
15126       printf (_("    Linker id: %s\n"), pnote->descdata);
15127       break;
15128     default:
15129       break;
15130     }
15131   return 1;
15132 }
15133
15134 /* Note that by the ELF standard, the name field is already null byte
15135    terminated, and namesz includes the terminating null byte.
15136    I.E. the value of namesz for the name "FSF" is 4.
15137
15138    If the value of namesz is zero, there is no name present.  */
15139 static int
15140 process_note (Elf_Internal_Note * pnote)
15141 {
15142   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15143   const char * nt;
15144
15145   if (pnote->namesz == 0)
15146     /* If there is no note name, then use the default set of
15147        note type strings.  */
15148     nt = get_note_type (pnote->type);
15149
15150   else if (const_strneq (pnote->namedata, "GNU"))
15151     /* GNU-specific object file notes.  */
15152     nt = get_gnu_elf_note_type (pnote->type);
15153
15154   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15155     /* NetBSD-specific core file notes.  */
15156     nt = get_netbsd_elfcore_note_type (pnote->type);
15157
15158   else if (strneq (pnote->namedata, "SPU/", 4))
15159     {
15160       /* SPU-specific core file notes.  */
15161       nt = pnote->namedata + 4;
15162       name = "SPU";
15163     }
15164
15165   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15166     /* VMS/ia64-specific file notes.  */
15167     nt = get_ia64_vms_note_type (pnote->type);
15168
15169   else if (const_strneq (pnote->namedata, "stapsdt"))
15170     nt = get_stapsdt_note_type (pnote->type);
15171
15172   else
15173     /* Don't recognize this note name; just use the default set of
15174        note type strings.  */
15175     nt = get_note_type (pnote->type);
15176
15177   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15178
15179   if (const_strneq (pnote->namedata, "IPF/VMS"))
15180     return print_ia64_vms_note (pnote);
15181   else if (const_strneq (pnote->namedata, "GNU"))
15182     return print_gnu_note (pnote);
15183   else if (const_strneq (pnote->namedata, "stapsdt"))
15184     return print_stapsdt_note (pnote);
15185   else if (const_strneq (pnote->namedata, "CORE"))
15186     return print_core_note (pnote);
15187   else
15188     return 1;
15189 }
15190
15191
15192 static int
15193 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15194 {
15195   Elf_External_Note * pnotes;
15196   Elf_External_Note * external;
15197   char * end;
15198   int res = 1;
15199
15200   if (length <= 0)
15201     return 0;
15202
15203   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15204                                            _("notes"));
15205   if (pnotes == NULL)
15206     return 0;
15207
15208   external = pnotes;
15209
15210   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15211           (unsigned long) offset, (unsigned long) length);
15212   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15213
15214   end = (char *) pnotes + length;
15215   while ((char *) external < end)
15216     {
15217       Elf_Internal_Note inote;
15218       size_t min_notesz;
15219       char *next;
15220       char * temp = NULL;
15221       size_t data_remaining = end - (char *) external;
15222
15223       if (!is_ia64_vms ())
15224         {
15225           /* PR binutils/15191
15226              Make sure that there is enough data to read.  */
15227           min_notesz = offsetof (Elf_External_Note, name);
15228           if (data_remaining < min_notesz)
15229             {
15230               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15231                     (int) data_remaining);
15232               break;
15233             }
15234           inote.type     = BYTE_GET (external->type);
15235           inote.namesz   = BYTE_GET (external->namesz);
15236           inote.namedata = external->name;
15237           inote.descsz   = BYTE_GET (external->descsz);
15238           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15239           /* PR 17531: file: 3443835e.  */
15240           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15241             {
15242               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15243               inote.descdata = inote.namedata;
15244               inote.namesz   = 0;
15245             }
15246
15247           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15248           next = inote.descdata + align_power (inote.descsz, 2);
15249         }
15250       else
15251         {
15252           Elf64_External_VMS_Note *vms_external;
15253
15254           /* PR binutils/15191
15255              Make sure that there is enough data to read.  */
15256           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15257           if (data_remaining < min_notesz)
15258             {
15259               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15260                     (int) data_remaining);
15261               break;
15262             }
15263
15264           vms_external = (Elf64_External_VMS_Note *) external;
15265           inote.type     = BYTE_GET (vms_external->type);
15266           inote.namesz   = BYTE_GET (vms_external->namesz);
15267           inote.namedata = vms_external->name;
15268           inote.descsz   = BYTE_GET (vms_external->descsz);
15269           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15270           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15271           next = inote.descdata + align_power (inote.descsz, 3);
15272         }
15273
15274       if (inote.descdata < (char *) external + min_notesz
15275           || next < (char *) external + min_notesz
15276           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15277           || inote.namedata + inote.namesz < inote.namedata
15278           || inote.descdata + inote.descsz < inote.descdata
15279           || data_remaining < (size_t)(next - (char *) external))
15280         {
15281           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15282                 (unsigned long) ((char *) external - (char *) pnotes));
15283           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15284                 inote.type, inote.namesz, inote.descsz);
15285           break;
15286         }
15287
15288       external = (Elf_External_Note *) next;
15289
15290       /* Verify that name is null terminated.  It appears that at least
15291          one version of Linux (RedHat 6.0) generates corefiles that don't
15292          comply with the ELF spec by failing to include the null byte in
15293          namesz.  */
15294       if (inote.namedata[inote.namesz - 1] != '\0')
15295         {
15296           temp = (char *) malloc (inote.namesz + 1);
15297           if (temp == NULL)
15298             {
15299               error (_("Out of memory allocating space for inote name\n"));
15300               res = 0;
15301               break;
15302             }
15303
15304           strncpy (temp, inote.namedata, inote.namesz);
15305           temp[inote.namesz] = 0;
15306
15307           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15308           inote.namedata = temp;
15309         }
15310
15311       res &= process_note (& inote);
15312
15313       if (temp != NULL)
15314         {
15315           free (temp);
15316           temp = NULL;
15317         }
15318     }
15319
15320   free (pnotes);
15321
15322   return res;
15323 }
15324
15325 static int
15326 process_corefile_note_segments (FILE * file)
15327 {
15328   Elf_Internal_Phdr * segment;
15329   unsigned int i;
15330   int res = 1;
15331
15332   if (! get_program_headers (file))
15333       return 0;
15334
15335   for (i = 0, segment = program_headers;
15336        i < elf_header.e_phnum;
15337        i++, segment++)
15338     {
15339       if (segment->p_type == PT_NOTE)
15340         res &= process_corefile_note_segment (file,
15341                                               (bfd_vma) segment->p_offset,
15342                                               (bfd_vma) segment->p_filesz);
15343     }
15344
15345   return res;
15346 }
15347
15348 static int
15349 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15350 {
15351   Elf_External_Note * pnotes;
15352   Elf_External_Note * external;
15353   char * end;
15354   int res = 1;
15355
15356   if (length <= 0)
15357     return 0;
15358
15359   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15360                                            _("v850 notes"));
15361   if (pnotes == NULL)
15362     return 0;
15363
15364   external = pnotes;
15365   end = (char*) pnotes + length;
15366
15367   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15368           (unsigned long) offset, (unsigned long) length);
15369
15370   while ((char *) external + sizeof (Elf_External_Note) < end)
15371     {
15372       Elf_External_Note * next;
15373       Elf_Internal_Note inote;
15374
15375       inote.type     = BYTE_GET (external->type);
15376       inote.namesz   = BYTE_GET (external->namesz);
15377       inote.namedata = external->name;
15378       inote.descsz   = BYTE_GET (external->descsz);
15379       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15380       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15381
15382       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15383         {
15384           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15385           inote.descdata = inote.namedata;
15386           inote.namesz   = 0;
15387         }
15388
15389       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15390
15391       if (   ((char *) next > end)
15392           || ((char *) next <  (char *) pnotes))
15393         {
15394           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15395                 (unsigned long) ((char *) external - (char *) pnotes));
15396           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15397                 inote.type, inote.namesz, inote.descsz);
15398           break;
15399         }
15400
15401       external = next;
15402
15403       /* Prevent out-of-bounds indexing.  */
15404       if (   inote.namedata + inote.namesz > end
15405           || inote.namedata + inote.namesz < inote.namedata)
15406         {
15407           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15408                 (unsigned long) ((char *) external - (char *) pnotes));
15409           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15410                 inote.type, inote.namesz, inote.descsz);
15411           break;
15412         }
15413
15414       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15415
15416       if (! print_v850_note (& inote))
15417         {
15418           res = 0;
15419           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15420                   inote.namesz, inote.descsz);
15421         }
15422     }
15423
15424   free (pnotes);
15425
15426   return res;
15427 }
15428
15429 static int
15430 process_note_sections (FILE * file)
15431 {
15432   Elf_Internal_Shdr * section;
15433   unsigned long i;
15434   int n = 0;
15435   int res = 1;
15436
15437   for (i = 0, section = section_headers;
15438        i < elf_header.e_shnum && section != NULL;
15439        i++, section++)
15440     {
15441       if (section->sh_type == SHT_NOTE)
15442         {
15443           res &= process_corefile_note_segment (file,
15444                                                 (bfd_vma) section->sh_offset,
15445                                                 (bfd_vma) section->sh_size);
15446           n++;
15447         }
15448
15449       if ((   elf_header.e_machine == EM_V800
15450            || elf_header.e_machine == EM_V850
15451            || elf_header.e_machine == EM_CYGNUS_V850)
15452           && section->sh_type == SHT_RENESAS_INFO)
15453         {
15454           res &= process_v850_notes (file,
15455                                      (bfd_vma) section->sh_offset,
15456                                      (bfd_vma) section->sh_size);
15457           n++;
15458         }
15459     }
15460
15461   if (n == 0)
15462     /* Try processing NOTE segments instead.  */
15463     return process_corefile_note_segments (file);
15464
15465   return res;
15466 }
15467
15468 static int
15469 process_notes (FILE * file)
15470 {
15471   /* If we have not been asked to display the notes then do nothing.  */
15472   if (! do_notes)
15473     return 1;
15474
15475   if (elf_header.e_type != ET_CORE)
15476     return process_note_sections (file);
15477
15478   /* No program headers means no NOTE segment.  */
15479   if (elf_header.e_phnum > 0)
15480     return process_corefile_note_segments (file);
15481
15482   printf (_("No note segments present in the core file.\n"));
15483   return 1;
15484 }
15485
15486 static int
15487 process_arch_specific (FILE * file)
15488 {
15489   if (! do_arch)
15490     return 1;
15491
15492   switch (elf_header.e_machine)
15493     {
15494     case EM_ARM:
15495       return process_arm_specific (file);
15496     case EM_MIPS:
15497     case EM_MIPS_RS3_LE:
15498       return process_mips_specific (file);
15499       break;
15500     case EM_NDS32:
15501       return process_nds32_specific (file);
15502       break;
15503     case EM_PPC:
15504       return process_power_specific (file);
15505       break;
15506     case EM_SPARC:
15507     case EM_SPARC32PLUS:
15508     case EM_SPARCV9:
15509       return process_sparc_specific (file);
15510       break;
15511     case EM_TI_C6000:
15512       return process_tic6x_specific (file);
15513       break;
15514     case EM_MSP430:
15515       return process_msp430x_specific (file);
15516     default:
15517       break;
15518     }
15519   return 1;
15520 }
15521
15522 static int
15523 get_file_header (FILE * file)
15524 {
15525   /* Read in the identity array.  */
15526   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15527     return 0;
15528
15529   /* Determine how to read the rest of the header.  */
15530   switch (elf_header.e_ident[EI_DATA])
15531     {
15532     default: /* fall through */
15533     case ELFDATANONE: /* fall through */
15534     case ELFDATA2LSB:
15535       byte_get = byte_get_little_endian;
15536       byte_put = byte_put_little_endian;
15537       break;
15538     case ELFDATA2MSB:
15539       byte_get = byte_get_big_endian;
15540       byte_put = byte_put_big_endian;
15541       break;
15542     }
15543
15544   /* For now we only support 32 bit and 64 bit ELF files.  */
15545   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15546
15547   /* Read in the rest of the header.  */
15548   if (is_32bit_elf)
15549     {
15550       Elf32_External_Ehdr ehdr32;
15551
15552       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15553         return 0;
15554
15555       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15556       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15557       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15558       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15559       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15560       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15561       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15562       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15563       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15564       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15565       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15566       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15567       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15568     }
15569   else
15570     {
15571       Elf64_External_Ehdr ehdr64;
15572
15573       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15574          we will not be able to cope with the 64bit data found in
15575          64 ELF files.  Detect this now and abort before we start
15576          overwriting things.  */
15577       if (sizeof (bfd_vma) < 8)
15578         {
15579           error (_("This instance of readelf has been built without support for a\n\
15580 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15581           return 0;
15582         }
15583
15584       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15585         return 0;
15586
15587       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15588       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15589       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15590       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15591       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15592       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15593       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15594       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15595       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15596       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15597       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15598       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15599       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15600     }
15601
15602   if (elf_header.e_shoff)
15603     {
15604       /* There may be some extensions in the first section header.  Don't
15605          bomb if we can't read it.  */
15606       if (is_32bit_elf)
15607         get_32bit_section_headers (file, TRUE);
15608       else
15609         get_64bit_section_headers (file, TRUE);
15610     }
15611
15612   return 1;
15613 }
15614
15615 /* Process one ELF object file according to the command line options.
15616    This file may actually be stored in an archive.  The file is
15617    positioned at the start of the ELF object.  */
15618
15619 static int
15620 process_object (char * file_name, FILE * file)
15621 {
15622   unsigned int i;
15623
15624   if (! get_file_header (file))
15625     {
15626       error (_("%s: Failed to read file header\n"), file_name);
15627       return 1;
15628     }
15629
15630   /* Initialise per file variables.  */
15631   for (i = ARRAY_SIZE (version_info); i--;)
15632     version_info[i] = 0;
15633
15634   for (i = ARRAY_SIZE (dynamic_info); i--;)
15635     dynamic_info[i] = 0;
15636   dynamic_info_DT_GNU_HASH = 0;
15637
15638   /* Process the file.  */
15639   if (show_name)
15640     printf (_("\nFile: %s\n"), file_name);
15641
15642   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15643      Note we do this even if cmdline_dump_sects is empty because we
15644      must make sure that the dump_sets array is zeroed out before each
15645      object file is processed.  */
15646   if (num_dump_sects > num_cmdline_dump_sects)
15647     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15648
15649   if (num_cmdline_dump_sects > 0)
15650     {
15651       if (num_dump_sects == 0)
15652         /* A sneaky way of allocating the dump_sects array.  */
15653         request_dump_bynumber (num_cmdline_dump_sects, 0);
15654
15655       assert (num_dump_sects >= num_cmdline_dump_sects);
15656       memcpy (dump_sects, cmdline_dump_sects,
15657               num_cmdline_dump_sects * sizeof (* dump_sects));
15658     }
15659
15660   if (! process_file_header ())
15661     return 1;
15662
15663   if (! process_section_headers (file))
15664     {
15665       /* Without loaded section headers we cannot process lots of
15666          things.  */
15667       do_unwind = do_version = do_dump = do_arch = 0;
15668
15669       if (! do_using_dynamic)
15670         do_syms = do_dyn_syms = do_reloc = 0;
15671     }
15672
15673   if (! process_section_groups (file))
15674     {
15675       /* Without loaded section groups we cannot process unwind.  */
15676       do_unwind = 0;
15677     }
15678
15679   if (process_program_headers (file))
15680     process_dynamic_section (file);
15681
15682   process_relocs (file);
15683
15684   process_unwind (file);
15685
15686   process_symbol_table (file);
15687
15688   process_syminfo (file);
15689
15690   process_version_sections (file);
15691
15692   process_section_contents (file);
15693
15694   process_notes (file);
15695
15696   process_gnu_liblist (file);
15697
15698   process_arch_specific (file);
15699
15700   if (program_headers)
15701     {
15702       free (program_headers);
15703       program_headers = NULL;
15704     }
15705
15706   if (section_headers)
15707     {
15708       free (section_headers);
15709       section_headers = NULL;
15710     }
15711
15712   if (string_table)
15713     {
15714       free (string_table);
15715       string_table = NULL;
15716       string_table_length = 0;
15717     }
15718
15719   if (dynamic_strings)
15720     {
15721       free (dynamic_strings);
15722       dynamic_strings = NULL;
15723       dynamic_strings_length = 0;
15724     }
15725
15726   if (dynamic_symbols)
15727     {
15728       free (dynamic_symbols);
15729       dynamic_symbols = NULL;
15730       num_dynamic_syms = 0;
15731     }
15732
15733   if (dynamic_syminfo)
15734     {
15735       free (dynamic_syminfo);
15736       dynamic_syminfo = NULL;
15737     }
15738
15739   if (dynamic_section)
15740     {
15741       free (dynamic_section);
15742       dynamic_section = NULL;
15743     }
15744
15745   if (section_headers_groups)
15746     {
15747       free (section_headers_groups);
15748       section_headers_groups = NULL;
15749     }
15750
15751   if (section_groups)
15752     {
15753       struct group_list * g;
15754       struct group_list * next;
15755
15756       for (i = 0; i < group_count; i++)
15757         {
15758           for (g = section_groups [i].root; g != NULL; g = next)
15759             {
15760               next = g->next;
15761               free (g);
15762             }
15763         }
15764
15765       free (section_groups);
15766       section_groups = NULL;
15767     }
15768
15769   free_debug_memory ();
15770
15771   return 0;
15772 }
15773
15774 /* Process an ELF archive.
15775    On entry the file is positioned just after the ARMAG string.  */
15776
15777 static int
15778 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15779 {
15780   struct archive_info arch;
15781   struct archive_info nested_arch;
15782   size_t got;
15783   int ret;
15784
15785   show_name = 1;
15786
15787   /* The ARCH structure is used to hold information about this archive.  */
15788   arch.file_name = NULL;
15789   arch.file = NULL;
15790   arch.index_array = NULL;
15791   arch.sym_table = NULL;
15792   arch.longnames = NULL;
15793
15794   /* The NESTED_ARCH structure is used as a single-item cache of information
15795      about a nested archive (when members of a thin archive reside within
15796      another regular archive file).  */
15797   nested_arch.file_name = NULL;
15798   nested_arch.file = NULL;
15799   nested_arch.index_array = NULL;
15800   nested_arch.sym_table = NULL;
15801   nested_arch.longnames = NULL;
15802
15803   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15804     {
15805       ret = 1;
15806       goto out;
15807     }
15808
15809   if (do_archive_index)
15810     {
15811       if (arch.sym_table == NULL)
15812         error (_("%s: unable to dump the index as none was found\n"), file_name);
15813       else
15814         {
15815           unsigned long i, l;
15816           unsigned long current_pos;
15817
15818           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15819                   file_name, (unsigned long) arch.index_num, arch.sym_size);
15820           current_pos = ftell (file);
15821
15822           for (i = l = 0; i < arch.index_num; i++)
15823             {
15824               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15825                 {
15826                   char * member_name;
15827
15828                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15829
15830                   if (member_name != NULL)
15831                     {
15832                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15833
15834                       if (qualified_name != NULL)
15835                         {
15836                           printf (_("Contents of binary %s at offset "), qualified_name);
15837                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
15838                           putchar ('\n');
15839                           free (qualified_name);
15840                         }
15841                     }
15842                 }
15843
15844               if (l >= arch.sym_size)
15845                 {
15846                   error (_("%s: end of the symbol table reached before the end of the index\n"),
15847                          file_name);
15848                   break;
15849                 }
15850               /* PR 17531: file: 0b6630b2.  */
15851               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15852               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15853             }
15854
15855           if (arch.uses_64bit_indicies)
15856             l = (l + 7) & ~ 7;
15857           else
15858             l += l & 1;
15859
15860           if (l < arch.sym_size)
15861             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15862                    file_name, arch.sym_size - l);
15863
15864           if (fseek (file, current_pos, SEEK_SET) != 0)
15865             {
15866               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15867               ret = 1;
15868               goto out;
15869             }
15870         }
15871
15872       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15873           && !do_segments && !do_header && !do_dump && !do_version
15874           && !do_histogram && !do_debugging && !do_arch && !do_notes
15875           && !do_section_groups && !do_dyn_syms)
15876         {
15877           ret = 0; /* Archive index only.  */
15878           goto out;
15879         }
15880     }
15881
15882   ret = 0;
15883
15884   while (1)
15885     {
15886       char * name;
15887       size_t namelen;
15888       char * qualified_name;
15889
15890       /* Read the next archive header.  */
15891       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15892         {
15893           error (_("%s: failed to seek to next archive header\n"), file_name);
15894           return 1;
15895         }
15896       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15897       if (got != sizeof arch.arhdr)
15898         {
15899           if (got == 0)
15900             break;
15901           error (_("%s: failed to read archive header\n"), file_name);
15902           ret = 1;
15903           break;
15904         }
15905       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15906         {
15907           error (_("%s: did not find a valid archive header\n"), arch.file_name);
15908           ret = 1;
15909           break;
15910         }
15911
15912       arch.next_arhdr_offset += sizeof arch.arhdr;
15913
15914       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15915       if (archive_file_size & 01)
15916         ++archive_file_size;
15917
15918       name = get_archive_member_name (&arch, &nested_arch);
15919       if (name == NULL)
15920         {
15921           error (_("%s: bad archive file name\n"), file_name);
15922           ret = 1;
15923           break;
15924         }
15925       namelen = strlen (name);
15926
15927       qualified_name = make_qualified_name (&arch, &nested_arch, name);
15928       if (qualified_name == NULL)
15929         {
15930           error (_("%s: bad archive file name\n"), file_name);
15931           ret = 1;
15932           break;
15933         }
15934
15935       if (is_thin_archive && arch.nested_member_origin == 0)
15936         {
15937           /* This is a proxy for an external member of a thin archive.  */
15938           FILE * member_file;
15939           char * member_file_name = adjust_relative_path (file_name, name, namelen);
15940           if (member_file_name == NULL)
15941             {
15942               ret = 1;
15943               break;
15944             }
15945
15946           member_file = fopen (member_file_name, "rb");
15947           if (member_file == NULL)
15948             {
15949               error (_("Input file '%s' is not readable.\n"), member_file_name);
15950               free (member_file_name);
15951               ret = 1;
15952               break;
15953             }
15954
15955           archive_file_offset = arch.nested_member_origin;
15956
15957           ret |= process_object (qualified_name, member_file);
15958
15959           fclose (member_file);
15960           free (member_file_name);
15961         }
15962       else if (is_thin_archive)
15963         {
15964           /* PR 15140: Allow for corrupt thin archives.  */
15965           if (nested_arch.file == NULL)
15966             {
15967               error (_("%s: contains corrupt thin archive: %s\n"),
15968                      file_name, name);
15969               ret = 1;
15970               break;
15971             }
15972
15973           /* This is a proxy for a member of a nested archive.  */
15974           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15975
15976           /* The nested archive file will have been opened and setup by
15977              get_archive_member_name.  */
15978           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15979             {
15980               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15981               ret = 1;
15982               break;
15983             }
15984
15985           ret |= process_object (qualified_name, nested_arch.file);
15986         }
15987       else
15988         {
15989           archive_file_offset = arch.next_arhdr_offset;
15990           arch.next_arhdr_offset += archive_file_size;
15991
15992           ret |= process_object (qualified_name, file);
15993         }
15994
15995       if (dump_sects != NULL)
15996         {
15997           free (dump_sects);
15998           dump_sects = NULL;
15999           num_dump_sects = 0;
16000         }
16001
16002       free (qualified_name);
16003     }
16004
16005  out:
16006   if (nested_arch.file != NULL)
16007     fclose (nested_arch.file);
16008   release_archive (&nested_arch);
16009   release_archive (&arch);
16010
16011   return ret;
16012 }
16013
16014 static int
16015 process_file (char * file_name)
16016 {
16017   FILE * file;
16018   struct stat statbuf;
16019   char armag[SARMAG];
16020   int ret;
16021
16022   if (stat (file_name, &statbuf) < 0)
16023     {
16024       if (errno == ENOENT)
16025         error (_("'%s': No such file\n"), file_name);
16026       else
16027         error (_("Could not locate '%s'.  System error message: %s\n"),
16028                file_name, strerror (errno));
16029       return 1;
16030     }
16031
16032   if (! S_ISREG (statbuf.st_mode))
16033     {
16034       error (_("'%s' is not an ordinary file\n"), file_name);
16035       return 1;
16036     }
16037
16038   file = fopen (file_name, "rb");
16039   if (file == NULL)
16040     {
16041       error (_("Input file '%s' is not readable.\n"), file_name);
16042       return 1;
16043     }
16044
16045   if (fread (armag, SARMAG, 1, file) != 1)
16046     {
16047       error (_("%s: Failed to read file's magic number\n"), file_name);
16048       fclose (file);
16049       return 1;
16050     }
16051
16052   current_file_size = (bfd_size_type) statbuf.st_size;
16053
16054   if (memcmp (armag, ARMAG, SARMAG) == 0)
16055     ret = process_archive (file_name, file, FALSE);
16056   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16057     ret = process_archive (file_name, file, TRUE);
16058   else
16059     {
16060       if (do_archive_index)
16061         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16062                file_name);
16063
16064       rewind (file);
16065       archive_file_size = archive_file_offset = 0;
16066       ret = process_object (file_name, file);
16067     }
16068
16069   fclose (file);
16070
16071   current_file_size = 0;
16072   return ret;
16073 }
16074
16075 #ifdef SUPPORT_DISASSEMBLY
16076 /* Needed by the i386 disassembler.  For extra credit, someone could
16077    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16078    symbols.  */
16079
16080 void
16081 print_address (unsigned int addr, FILE * outfile)
16082 {
16083   fprintf (outfile,"0x%8.8x", addr);
16084 }
16085
16086 /* Needed by the i386 disassembler.  */
16087 void
16088 db_task_printsym (unsigned int addr)
16089 {
16090   print_address (addr, stderr);
16091 }
16092 #endif
16093
16094 int
16095 main (int argc, char ** argv)
16096 {
16097   int err;
16098
16099 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16100   setlocale (LC_MESSAGES, "");
16101 #endif
16102 #if defined (HAVE_SETLOCALE)
16103   setlocale (LC_CTYPE, "");
16104 #endif
16105   bindtextdomain (PACKAGE, LOCALEDIR);
16106   textdomain (PACKAGE);
16107
16108   expandargv (&argc, &argv);
16109
16110   parse_args (argc, argv);
16111
16112   if (num_dump_sects > 0)
16113     {
16114       /* Make a copy of the dump_sects array.  */
16115       cmdline_dump_sects = (dump_type *)
16116           malloc (num_dump_sects * sizeof (* dump_sects));
16117       if (cmdline_dump_sects == NULL)
16118         error (_("Out of memory allocating dump request table.\n"));
16119       else
16120         {
16121           memcpy (cmdline_dump_sects, dump_sects,
16122                   num_dump_sects * sizeof (* dump_sects));
16123           num_cmdline_dump_sects = num_dump_sects;
16124         }
16125     }
16126
16127   if (optind < (argc - 1))
16128     show_name = 1;
16129   else if (optind >= argc)
16130     {
16131       warn (_("Nothing to do.\n"));
16132       usage (stderr);
16133     }
16134
16135   err = 0;
16136   while (optind < argc)
16137     err |= process_file (argv[optind++]);
16138
16139   if (dump_sects != NULL)
16140     free (dump_sects);
16141   if (cmdline_dump_sects != NULL)
16142     free (cmdline_dump_sects);
16143
16144   return err;
16145 }