binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2014 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/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nds32.h"
 135 #include "elf/nios2.h"
 136 #include "elf/or1k.h"
 137 #include "elf/pj.h"
 138 #include "elf/ppc.h"
 139 #include "elf/ppc64.h"
 140 #include "elf/rl78.h"
 141 #include "elf/rx.h"
 142 #include "elf/s390.h"
 143 #include "elf/score.h"
 144 #include "elf/sh.h"
 145 #include "elf/sparc.h"
 146 #include "elf/spu.h"
 147 #include "elf/tic6x.h"
 148 #include "elf/tilegx.h"
 149 #include "elf/tilepro.h"
 150 #include "elf/v850.h"
 151 #include "elf/vax.h"
 152 #include "elf/x86-64.h"
 153 #include "elf/xc16x.h"
 154 #include "elf/xgate.h"
 155 #include "elf/xstormy16.h"
 156 #include "elf/xtensa.h"
 157
 158 #include "getopt.h"
 159 #include "libiberty.h"
 160 #include "safe-ctype.h"
 161 #include "filenames.h"
 162
 163 #ifndef offsetof
 164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 165 #endif
 166
 167 char * program_name = "readelf";
 168 static long archive_file_offset;
 169 static unsigned long archive_file_size;
 170 static bfd_size_type current_file_size;
 171 static unsigned long dynamic_addr;
 172 static bfd_size_type dynamic_size;
 173 static unsigned int dynamic_nent;
 174 static char * dynamic_strings;
 175 static unsigned long dynamic_strings_length;
 176 static char * string_table;
 177 static unsigned long string_table_length;
 178 static unsigned long num_dynamic_syms;
 179 static Elf_Internal_Sym * dynamic_symbols;
 180 static Elf_Internal_Syminfo * dynamic_syminfo;
 181 static unsigned long dynamic_syminfo_offset;
 182 static unsigned int dynamic_syminfo_nent;
 183 static char program_interpreter[PATH_MAX];
 184 static bfd_vma dynamic_info[DT_ENCODING];
 185 static bfd_vma dynamic_info_DT_GNU_HASH;
 186 static bfd_vma version_info[16];
 187 static Elf_Internal_Ehdr elf_header;
 188 static Elf_Internal_Shdr * section_headers;
 189 static Elf_Internal_Phdr * program_headers;
 190 static Elf_Internal_Dyn *  dynamic_section;
 191 static Elf_Internal_Shdr * symtab_shndx_hdr;
 192 static int show_name;
 193 static int do_dynamic;
 194 static int do_syms;
 195 static int do_dyn_syms;
 196 static int do_reloc;
 197 static int do_sections;
 198 static int do_section_groups;
 199 static int do_section_details;
 200 static int do_segments;
 201 static int do_unwind;
 202 static int do_using_dynamic;
 203 static int do_header;
 204 static int do_dump;
 205 static int do_version;
 206 static int do_histogram;
 207 static int do_debugging;
 208 static int do_arch;
 209 static int do_notes;
 210 static int do_archive_index;
 211 static int is_32bit_elf;
 212
 213 struct group_list
 214 {
 215   struct group_list * next;
 216   unsigned int section_index;
 217 };
 218
 219 struct group
 220 {
 221   struct group_list * root;
 222   unsigned int group_index;
 223 };
 224
 225 static size_t group_count;
 226 static struct group * section_groups;
 227 static struct group ** section_headers_groups;
 228
 229
 230 /* Flag bits indicating particular types of dump.  */
 231 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 232 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 233 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 234 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 235 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 236
 237 typedef unsigned char dump_type;
 238
 239 /* A linked list of the section names for which dumps were requested.  */
 240 struct dump_list_entry
 241 {
 242   char * name;
 243   dump_type type;
 244   struct dump_list_entry * next;
 245 };
 246 static struct dump_list_entry * dump_sects_byname;
 247
 248 /* A dynamic array of flags indicating for which sections a dump
 249    has been requested via command line switches.  */
 250 static dump_type *   cmdline_dump_sects = NULL;
 251 static unsigned int  num_cmdline_dump_sects = 0;
 252
 253 /* A dynamic array of flags indicating for which sections a dump of
 254    some kind has been requested.  It is reset on a per-object file
 255    basis and then initialised from the cmdline_dump_sects array,
 256    the results of interpreting the -w switch, and the
 257    dump_sects_byname list.  */
 258 static dump_type *   dump_sects = NULL;
 259 static unsigned int  num_dump_sects = 0;
 260
 261
 262 /* How to print a vma value.  */
 263 typedef enum print_mode
 264 {
 265   HEX,
 266   DEC,
 267   DEC_5,
 268   UNSIGNED,
 269   PREFIX_HEX,
 270   FULL_HEX,
 271   LONG_HEX
 272 }
 273 print_mode;
 274
 275 #define UNKNOWN -1
 276
 277 #define SECTION_NAME(X)                                         \
 278   ((X) == NULL ? _("<none>")                                    \
 279    : string_table == NULL ? _("<no-name>")                      \
 280    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 281   : string_table + (X)->sh_name))
 282
 283 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 284
 285 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 286   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 287    : get_64bit_elf_symbols (file, section, sym_count))
 288
 289 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 290 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 291    already been called and verified that the string exists.  */
 292 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 293
 294 #define REMOVE_ARCH_BITS(ADDR)                  \
 295   do                                            \
 296     {                                           \
 297       if (elf_header.e_machine == EM_ARM)       \
 298         (ADDR) &= ~1;                           \
 299     }                                           \
 300   while (0)
 301 \f
 302 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 303    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 304    using malloc and fill that.  In either case return the pointer to the start of
 305    the retrieved data or NULL if something went wrong.  If something does go wrong
 306    emit an error message using REASON as part of the context.  */
 307
 308 static void *
 309 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 310           const char * reason)
 311 {
 312   void * mvar;
 313
 314   if (size == 0 || nmemb == 0)
 315     return NULL;
 316
 317   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 318     {
 319       if (reason)
 320         error (_("Unable to seek to 0x%lx for %s\n"),
 321                (unsigned long) archive_file_offset + offset, reason);
 322       return NULL;
 323     }
 324
 325   mvar = var;
 326   if (mvar == NULL)
 327     {
 328       /* Check for overflow.  */
 329       if (nmemb < (~(size_t) 0 - 1) / size)
 330         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 331         mvar = malloc (size * nmemb + 1);
 332
 333       if (mvar == NULL)
 334         {
 335           if (reason)
 336             error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 337                    (unsigned long)(size * nmemb), reason);
 338           return NULL;
 339         }
 340
 341       ((char *) mvar)[size * nmemb] = '\0';
 342     }
 343
 344   if (fread (mvar, size, nmemb, file) != nmemb)
 345     {
 346       if (reason)
 347         error (_("Unable to read in 0x%lx bytes of %s\n"),
 348                (unsigned long)(size * nmemb), reason);
 349       if (mvar != var)
 350         free (mvar);
 351       return NULL;
 352     }
 353
 354   return mvar;
 355 }
 356
 357 /* Print a VMA value.  */
 358
 359 static int
 360 print_vma (bfd_vma vma, print_mode mode)
 361 {
 362   int nc = 0;
 363
 364   switch (mode)
 365     {
 366     case FULL_HEX:
 367       nc = printf ("0x");
 368       /* Drop through.  */
 369
 370     case LONG_HEX:
 371 #ifdef BFD64
 372       if (is_32bit_elf)
 373         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 374 #endif
 375       printf_vma (vma);
 376       return nc + 16;
 377
 378     case DEC_5:
 379       if (vma <= 99999)
 380         return printf ("%5" BFD_VMA_FMT "d", vma);
 381       /* Drop through.  */
 382
 383     case PREFIX_HEX:
 384       nc = printf ("0x");
 385       /* Drop through.  */
 386
 387     case HEX:
 388       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 389
 390     case DEC:
 391       return printf ("%" BFD_VMA_FMT "d", vma);
 392
 393     case UNSIGNED:
 394       return printf ("%" BFD_VMA_FMT "u", vma);
 395     }
 396   return 0;
 397 }
 398
 399 /* Display a symbol on stdout.  Handles the display of control characters and
 400    multibye characters (assuming the host environment supports them).
 401
 402    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 403
 404    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 405    padding as necessary.
 406
 407    Returns the number of emitted characters.  */
 408
 409 static unsigned int
 410 print_symbol (int width, const char *symbol)
 411 {
 412   bfd_boolean extra_padding = FALSE;
 413   int num_printed = 0;
 414 #ifdef HAVE_MBSTATE_T
 415   mbstate_t state;
 416 #endif
 417   int width_remaining;
 418
 419   if (width < 0)
 420     {
 421       /* Keep the width positive.  This also helps.  */
 422       width = - width;
 423       extra_padding = TRUE;
 424     }
 425   assert (width != 0);
 426
 427   if (do_wide)
 428     /* Set the remaining width to a very large value.
 429        This simplifies the code below.  */
 430     width_remaining = INT_MAX;
 431   else
 432     width_remaining = width;
 433
 434 #ifdef HAVE_MBSTATE_T
 435   /* Initialise the multibyte conversion state.  */
 436   memset (& state, 0, sizeof (state));
 437 #endif
 438
 439   while (width_remaining)
 440     {
 441       size_t  n;
 442       const char c = *symbol++;
 443
 444       if (c == 0)
 445         break;
 446
 447       /* Do not print control characters directly as they can affect terminal
 448          settings.  Such characters usually appear in the names generated
 449          by the assembler for local labels.  */
 450       if (ISCNTRL (c))
 451         {
 452           if (width_remaining < 2)
 453             break;
 454
 455           printf ("^%c", c + 0x40);
 456           width_remaining -= 2;
 457           num_printed += 2;
 458         }
 459       else if (ISPRINT (c))
 460         {
 461           putchar (c);
 462           width_remaining --;
 463           num_printed ++;
 464         }
 465       else
 466         {
 467 #ifdef HAVE_MBSTATE_T
 468           wchar_t w;
 469 #endif
 470           /* Let printf do the hard work of displaying multibyte characters.  */
 471           printf ("%.1s", symbol - 1);
 472           width_remaining --;
 473           num_printed ++;
 474
 475 #ifdef HAVE_MBSTATE_T
 476           /* Try to find out how many bytes made up the character that was
 477              just printed.  Advance the symbol pointer past the bytes that
 478              were displayed.  */
 479           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 480 #else
 481           n = 1;
 482 #endif
 483           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 484             symbol += (n - 1);
 485         }
 486     }
 487
 488   if (extra_padding && num_printed < width)
 489     {
 490       /* Fill in the remaining spaces.  */
 491       printf ("%-*s", width - num_printed, " ");
 492       num_printed = width;
 493     }
 494
 495   return num_printed;
 496 }
 497
 498 /* Returns a pointer to a static buffer containing a  printable version of
 499    the given section's name.  Like print_symbol, except that it does not try
 500    to print multibyte characters, it just interprets them as hex values.  */
 501
 502 static const char *
 503 printable_section_name (Elf_Internal_Shdr * sec)
 504 {
 505 #define MAX_PRINT_SEC_NAME_LEN 128
 506   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 507   const char * name = SECTION_NAME (sec);
 508   char *       buf = sec_name_buf;
 509   char         c;
 510   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 511
 512   while ((c = * name ++) != 0)
 513     {
 514       if (ISCNTRL (c))
 515         {
 516           if (remaining < 2)
 517             break;
 518
 519           * buf ++ = '^';
 520           * buf ++ = c + 0x40;
 521           remaining -= 2;
 522         }
 523       else if (ISPRINT (c))
 524         {
 525           * buf ++ = c;
 526           remaining -= 1;
 527         }
 528       else
 529         {
 530           static char hex[17] = "0123456789ABCDEF";
 531
 532           if (remaining < 4)
 533             break;
 534           * buf ++ = '<';
 535           * buf ++ = hex[(c & 0xf0) >> 4];
 536           * buf ++ = hex[c & 0x0f];
 537           * buf ++ = '>';
 538           remaining -= 4;
 539         }
 540
 541       if (remaining == 0)
 542         break;
 543     }
 544
 545   * buf = 0;
 546   return sec_name_buf;
 547 }
 548
 549 static const char *
 550 printable_section_name_from_index (unsigned long ndx)
 551 {
 552   if (ndx >= elf_header.e_shnum)
 553     return _("<corrupt>");
 554
 555   return printable_section_name (section_headers + ndx);
 556 }
 557
 558 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 559
 560 static Elf_Internal_Shdr *
 561 find_section (const char * name)
 562 {
 563   unsigned int i;
 564
 565   for (i = 0; i < elf_header.e_shnum; i++)
 566     if (streq (SECTION_NAME (section_headers + i), name))
 567       return section_headers + i;
 568
 569   return NULL;
 570 }
 571
 572 /* Return a pointer to a section containing ADDR, or NULL if no such
 573    section exists.  */
 574
 575 static Elf_Internal_Shdr *
 576 find_section_by_address (bfd_vma addr)
 577 {
 578   unsigned int i;
 579
 580   for (i = 0; i < elf_header.e_shnum; i++)
 581     {
 582       Elf_Internal_Shdr *sec = section_headers + i;
 583       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 584         return sec;
 585     }
 586
 587   return NULL;
 588 }
 589
 590 /* Return a pointer to section NAME, or NULL if no such section exists,
 591    restricted to the list of sections given in SET.  */
 592
 593 static Elf_Internal_Shdr *
 594 find_section_in_set (const char * name, unsigned int * set)
 595 {
 596   unsigned int i;
 597
 598   if (set != NULL)
 599     {
 600       while ((i = *set++) > 0)
 601         if (streq (SECTION_NAME (section_headers + i), name))
 602           return section_headers + i;
 603     }
 604
 605   return find_section (name);
 606 }
 607
 608 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 609    bytes read.  */
 610
 611 static inline unsigned long
 612 read_uleb128 (unsigned char *data,
 613               unsigned int *length_return,
 614               const unsigned char * const end)
 615 {
 616   return read_leb128 (data, length_return, FALSE, end);
 617 }
 618
 619 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 620    This OS has so many departures from the ELF standard that we test it at
 621    many places.  */
 622
 623 static inline int
 624 is_ia64_vms (void)
 625 {
 626   return elf_header.e_machine == EM_IA_64
 627     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 628 }
 629
 630 /* Guess the relocation size commonly used by the specific machines.  */
 631
 632 static int
 633 guess_is_rela (unsigned int e_machine)
 634 {
 635   switch (e_machine)
 636     {
 637       /* Targets that use REL relocations.  */
 638     case EM_386:
 639     case EM_486:
 640     case EM_960:
 641     case EM_ARM:
 642     case EM_D10V:
 643     case EM_CYGNUS_D10V:
 644     case EM_DLX:
 645     case EM_MIPS:
 646     case EM_MIPS_RS3_LE:
 647     case EM_CYGNUS_M32R:
 648     case EM_SCORE:
 649     case EM_XGATE:
 650       return FALSE;
 651
 652       /* Targets that use RELA relocations.  */
 653     case EM_68K:
 654     case EM_860:
 655     case EM_AARCH64:
 656     case EM_ADAPTEVA_EPIPHANY:
 657     case EM_ALPHA:
 658     case EM_ALTERA_NIOS2:
 659     case EM_AVR:
 660     case EM_AVR_OLD:
 661     case EM_BLACKFIN:
 662     case EM_CR16:
 663     case EM_CRIS:
 664     case EM_CRX:
 665     case EM_D30V:
 666     case EM_CYGNUS_D30V:
 667     case EM_FR30:
 668     case EM_CYGNUS_FR30:
 669     case EM_CYGNUS_FRV:
 670     case EM_H8S:
 671     case EM_H8_300:
 672     case EM_H8_300H:
 673     case EM_IA_64:
 674     case EM_IP2K:
 675     case EM_IP2K_OLD:
 676     case EM_IQ2000:
 677     case EM_LATTICEMICO32:
 678     case EM_M32C_OLD:
 679     case EM_M32C:
 680     case EM_M32R:
 681     case EM_MCORE:
 682     case EM_CYGNUS_MEP:
 683     case EM_METAG:
 684     case EM_MMIX:
 685     case EM_MN10200:
 686     case EM_CYGNUS_MN10200:
 687     case EM_MN10300:
 688     case EM_CYGNUS_MN10300:
 689     case EM_MOXIE:
 690     case EM_MSP430:
 691     case EM_MSP430_OLD:
 692     case EM_MT:
 693     case EM_NDS32:
 694     case EM_NIOS32:
 695     case EM_OR1K:
 696     case EM_PPC64:
 697     case EM_PPC:
 698     case EM_RL78:
 699     case EM_RX:
 700     case EM_S390:
 701     case EM_S390_OLD:
 702     case EM_SH:
 703     case EM_SPARC:
 704     case EM_SPARC32PLUS:
 705     case EM_SPARCV9:
 706     case EM_SPU:
 707     case EM_TI_C6000:
 708     case EM_TILEGX:
 709     case EM_TILEPRO:
 710     case EM_V800:
 711     case EM_V850:
 712     case EM_CYGNUS_V850:
 713     case EM_VAX:
 714     case EM_X86_64:
 715     case EM_L1OM:
 716     case EM_K1OM:
 717     case EM_XSTORMY16:
 718     case EM_XTENSA:
 719     case EM_XTENSA_OLD:
 720     case EM_MICROBLAZE:
 721     case EM_MICROBLAZE_OLD:
 722       return TRUE;
 723
 724     case EM_68HC05:
 725     case EM_68HC08:
 726     case EM_68HC11:
 727     case EM_68HC16:
 728     case EM_FX66:
 729     case EM_ME16:
 730     case EM_MMA:
 731     case EM_NCPU:
 732     case EM_NDR1:
 733     case EM_PCP:
 734     case EM_ST100:
 735     case EM_ST19:
 736     case EM_ST7:
 737     case EM_ST9PLUS:
 738     case EM_STARCORE:
 739     case EM_SVX:
 740     case EM_TINYJ:
 741     default:
 742       warn (_("Don't know about relocations on this machine architecture\n"));
 743       return FALSE;
 744     }
 745 }
 746
 747 static int
 748 slurp_rela_relocs (FILE * file,
 749                    unsigned long rel_offset,
 750                    unsigned long rel_size,
 751                    Elf_Internal_Rela ** relasp,
 752                    unsigned long * nrelasp)
 753 {
 754   Elf_Internal_Rela * relas;
 755   unsigned long nrelas;
 756   unsigned int i;
 757
 758   if (is_32bit_elf)
 759     {
 760       Elf32_External_Rela * erelas;
 761
 762       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 763                                                  rel_size, _("32-bit relocation data"));
 764       if (!erelas)
 765         return 0;
 766
 767       nrelas = rel_size / sizeof (Elf32_External_Rela);
 768
 769       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 770                                              sizeof (Elf_Internal_Rela));
 771
 772       if (relas == NULL)
 773         {
 774           free (erelas);
 775           error (_("out of memory parsing relocs\n"));
 776           return 0;
 777         }
 778
 779       for (i = 0; i < nrelas; i++)
 780         {
 781           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 782           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 783           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 784         }
 785
 786       free (erelas);
 787     }
 788   else
 789     {
 790       Elf64_External_Rela * erelas;
 791
 792       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 793                                                  rel_size, _("64-bit relocation data"));
 794       if (!erelas)
 795         return 0;
 796
 797       nrelas = rel_size / sizeof (Elf64_External_Rela);
 798
 799       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 800                                              sizeof (Elf_Internal_Rela));
 801
 802       if (relas == NULL)
 803         {
 804           free (erelas);
 805           error (_("out of memory parsing relocs\n"));
 806           return 0;
 807         }
 808
 809       for (i = 0; i < nrelas; i++)
 810         {
 811           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 812           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 813           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 814
 815           /* The #ifdef BFD64 below is to prevent a compile time
 816              warning.  We know that if we do not have a 64 bit data
 817              type that we will never execute this code anyway.  */
 818 #ifdef BFD64
 819           if (elf_header.e_machine == EM_MIPS
 820               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 821             {
 822               /* In little-endian objects, r_info isn't really a
 823                  64-bit little-endian value: it has a 32-bit
 824                  little-endian symbol index followed by four
 825                  individual byte fields.  Reorder INFO
 826                  accordingly.  */
 827               bfd_vma inf = relas[i].r_info;
 828               inf = (((inf & 0xffffffff) << 32)
 829                       | ((inf >> 56) & 0xff)
 830                       | ((inf >> 40) & 0xff00)
 831                       | ((inf >> 24) & 0xff0000)
 832                       | ((inf >> 8) & 0xff000000));
 833               relas[i].r_info = inf;
 834             }
 835 #endif /* BFD64 */
 836         }
 837
 838       free (erelas);
 839     }
 840   *relasp = relas;
 841   *nrelasp = nrelas;
 842   return 1;
 843 }
 844
 845 static int
 846 slurp_rel_relocs (FILE * file,
 847                   unsigned long rel_offset,
 848                   unsigned long rel_size,
 849                   Elf_Internal_Rela ** relsp,
 850                   unsigned long * nrelsp)
 851 {
 852   Elf_Internal_Rela * rels;
 853   unsigned long nrels;
 854   unsigned int i;
 855
 856   if (is_32bit_elf)
 857     {
 858       Elf32_External_Rel * erels;
 859
 860       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 861                                                rel_size, _("32-bit relocation data"));
 862       if (!erels)
 863         return 0;
 864
 865       nrels = rel_size / sizeof (Elf32_External_Rel);
 866
 867       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 868
 869       if (rels == NULL)
 870         {
 871           free (erels);
 872           error (_("out of memory parsing relocs\n"));
 873           return 0;
 874         }
 875
 876       for (i = 0; i < nrels; i++)
 877         {
 878           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 879           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 880           rels[i].r_addend = 0;
 881         }
 882
 883       free (erels);
 884     }
 885   else
 886     {
 887       Elf64_External_Rel * erels;
 888
 889       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 890                                                rel_size, _("64-bit relocation data"));
 891       if (!erels)
 892         return 0;
 893
 894       nrels = rel_size / sizeof (Elf64_External_Rel);
 895
 896       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 897
 898       if (rels == NULL)
 899         {
 900           free (erels);
 901           error (_("out of memory parsing relocs\n"));
 902           return 0;
 903         }
 904
 905       for (i = 0; i < nrels; i++)
 906         {
 907           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 908           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 909           rels[i].r_addend = 0;
 910
 911           /* The #ifdef BFD64 below is to prevent a compile time
 912              warning.  We know that if we do not have a 64 bit data
 913              type that we will never execute this code anyway.  */
 914 #ifdef BFD64
 915           if (elf_header.e_machine == EM_MIPS
 916               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 917             {
 918               /* In little-endian objects, r_info isn't really a
 919                  64-bit little-endian value: it has a 32-bit
 920                  little-endian symbol index followed by four
 921                  individual byte fields.  Reorder INFO
 922                  accordingly.  */
 923               bfd_vma inf = rels[i].r_info;
 924               inf = (((inf & 0xffffffff) << 32)
 925                      | ((inf >> 56) & 0xff)
 926                      | ((inf >> 40) & 0xff00)
 927                      | ((inf >> 24) & 0xff0000)
 928                      | ((inf >> 8) & 0xff000000));
 929               rels[i].r_info = inf;
 930             }
 931 #endif /* BFD64 */
 932         }
 933
 934       free (erels);
 935     }
 936   *relsp = rels;
 937   *nrelsp = nrels;
 938   return 1;
 939 }
 940
 941 /* Returns the reloc type extracted from the reloc info field.  */
 942
 943 static unsigned int
 944 get_reloc_type (bfd_vma reloc_info)
 945 {
 946   if (is_32bit_elf)
 947     return ELF32_R_TYPE (reloc_info);
 948
 949   switch (elf_header.e_machine)
 950     {
 951     case EM_MIPS:
 952       /* Note: We assume that reloc_info has already been adjusted for us.  */
 953       return ELF64_MIPS_R_TYPE (reloc_info);
 954
 955     case EM_SPARCV9:
 956       return ELF64_R_TYPE_ID (reloc_info);
 957
 958     default:
 959       return ELF64_R_TYPE (reloc_info);
 960     }
 961 }
 962
 963 /* Return the symbol index extracted from the reloc info field.  */
 964
 965 static bfd_vma
 966 get_reloc_symindex (bfd_vma reloc_info)
 967 {
 968   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 969 }
 970
 971 static inline bfd_boolean
 972 uses_msp430x_relocs (void)
 973 {
 974   return
 975     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 976     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 977     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 978         /* TI compiler uses ELFOSABI_NONE.  */
 979         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 980 }
 981
 982 /* Display the contents of the relocation data found at the specified
 983    offset.  */
 984
 985 static void
 986 dump_relocations (FILE * file,
 987                   unsigned long rel_offset,
 988                   unsigned long rel_size,
 989                   Elf_Internal_Sym * symtab,
 990                   unsigned long nsyms,
 991                   char * strtab,
 992                   unsigned long strtablen,
 993                   int is_rela)
 994 {
 995   unsigned int i;
 996   Elf_Internal_Rela * rels;
 997
 998   if (is_rela == UNKNOWN)
 999     is_rela = guess_is_rela (elf_header.e_machine);
1000
1001   if (is_rela)
1002     {
1003       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1004         return;
1005     }
1006   else
1007     {
1008       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1009         return;
1010     }
1011
1012   if (is_32bit_elf)
1013     {
1014       if (is_rela)
1015         {
1016           if (do_wide)
1017             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1018           else
1019             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1020         }
1021       else
1022         {
1023           if (do_wide)
1024             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1025           else
1026             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1027         }
1028     }
1029   else
1030     {
1031       if (is_rela)
1032         {
1033           if (do_wide)
1034             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1035           else
1036             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1037         }
1038       else
1039         {
1040           if (do_wide)
1041             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1042           else
1043             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1044         }
1045     }
1046
1047   for (i = 0; i < rel_size; i++)
1048     {
1049       const char * rtype;
1050       bfd_vma offset;
1051       bfd_vma inf;
1052       bfd_vma symtab_index;
1053       bfd_vma type;
1054
1055       offset = rels[i].r_offset;
1056       inf    = rels[i].r_info;
1057
1058       type = get_reloc_type (inf);
1059       symtab_index = get_reloc_symindex  (inf);
1060
1061       if (is_32bit_elf)
1062         {
1063           printf ("%8.8lx  %8.8lx ",
1064                   (unsigned long) offset & 0xffffffff,
1065                   (unsigned long) inf & 0xffffffff);
1066         }
1067       else
1068         {
1069 #if BFD_HOST_64BIT_LONG
1070           printf (do_wide
1071                   ? "%16.16lx  %16.16lx "
1072                   : "%12.12lx  %12.12lx ",
1073                   offset, inf);
1074 #elif BFD_HOST_64BIT_LONG_LONG
1075 #ifndef __MSVCRT__
1076           printf (do_wide
1077                   ? "%16.16llx  %16.16llx "
1078                   : "%12.12llx  %12.12llx ",
1079                   offset, inf);
1080 #else
1081           printf (do_wide
1082                   ? "%16.16I64x  %16.16I64x "
1083                   : "%12.12I64x  %12.12I64x ",
1084                   offset, inf);
1085 #endif
1086 #else
1087           printf (do_wide
1088                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1089                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1090                   _bfd_int64_high (offset),
1091                   _bfd_int64_low (offset),
1092                   _bfd_int64_high (inf),
1093                   _bfd_int64_low (inf));
1094 #endif
1095         }
1096
1097       switch (elf_header.e_machine)
1098         {
1099         default:
1100           rtype = NULL;
1101           break;
1102
1103         case EM_AARCH64:
1104           rtype = elf_aarch64_reloc_type (type);
1105           break;
1106
1107         case EM_M32R:
1108         case EM_CYGNUS_M32R:
1109           rtype = elf_m32r_reloc_type (type);
1110           break;
1111
1112         case EM_386:
1113         case EM_486:
1114           rtype = elf_i386_reloc_type (type);
1115           break;
1116
1117         case EM_68HC11:
1118         case EM_68HC12:
1119           rtype = elf_m68hc11_reloc_type (type);
1120           break;
1121
1122         case EM_68K:
1123           rtype = elf_m68k_reloc_type (type);
1124           break;
1125
1126         case EM_960:
1127           rtype = elf_i960_reloc_type (type);
1128           break;
1129
1130         case EM_AVR:
1131         case EM_AVR_OLD:
1132           rtype = elf_avr_reloc_type (type);
1133           break;
1134
1135         case EM_OLD_SPARCV9:
1136         case EM_SPARC32PLUS:
1137         case EM_SPARCV9:
1138         case EM_SPARC:
1139           rtype = elf_sparc_reloc_type (type);
1140           break;
1141
1142         case EM_SPU:
1143           rtype = elf_spu_reloc_type (type);
1144           break;
1145
1146         case EM_V800:
1147           rtype = v800_reloc_type (type);
1148           break;
1149         case EM_V850:
1150         case EM_CYGNUS_V850:
1151           rtype = v850_reloc_type (type);
1152           break;
1153
1154         case EM_D10V:
1155         case EM_CYGNUS_D10V:
1156           rtype = elf_d10v_reloc_type (type);
1157           break;
1158
1159         case EM_D30V:
1160         case EM_CYGNUS_D30V:
1161           rtype = elf_d30v_reloc_type (type);
1162           break;
1163
1164         case EM_DLX:
1165           rtype = elf_dlx_reloc_type (type);
1166           break;
1167
1168         case EM_SH:
1169           rtype = elf_sh_reloc_type (type);
1170           break;
1171
1172         case EM_MN10300:
1173         case EM_CYGNUS_MN10300:
1174           rtype = elf_mn10300_reloc_type (type);
1175           break;
1176
1177         case EM_MN10200:
1178         case EM_CYGNUS_MN10200:
1179           rtype = elf_mn10200_reloc_type (type);
1180           break;
1181
1182         case EM_FR30:
1183         case EM_CYGNUS_FR30:
1184           rtype = elf_fr30_reloc_type (type);
1185           break;
1186
1187         case EM_CYGNUS_FRV:
1188           rtype = elf_frv_reloc_type (type);
1189           break;
1190
1191         case EM_MCORE:
1192           rtype = elf_mcore_reloc_type (type);
1193           break;
1194
1195         case EM_MMIX:
1196           rtype = elf_mmix_reloc_type (type);
1197           break;
1198
1199         case EM_MOXIE:
1200           rtype = elf_moxie_reloc_type (type);
1201           break;
1202
1203         case EM_MSP430:
1204           if (uses_msp430x_relocs ())
1205             {
1206               rtype = elf_msp430x_reloc_type (type);
1207               break;
1208             }
1209         case EM_MSP430_OLD:
1210           rtype = elf_msp430_reloc_type (type);
1211           break;
1212
1213         case EM_NDS32:
1214           rtype = elf_nds32_reloc_type (type);
1215           break;
1216
1217         case EM_PPC:
1218           rtype = elf_ppc_reloc_type (type);
1219           break;
1220
1221         case EM_PPC64:
1222           rtype = elf_ppc64_reloc_type (type);
1223           break;
1224
1225         case EM_MIPS:
1226         case EM_MIPS_RS3_LE:
1227           rtype = elf_mips_reloc_type (type);
1228           break;
1229
1230         case EM_ALPHA:
1231           rtype = elf_alpha_reloc_type (type);
1232           break;
1233
1234         case EM_ARM:
1235           rtype = elf_arm_reloc_type (type);
1236           break;
1237
1238         case EM_ARC:
1239           rtype = elf_arc_reloc_type (type);
1240           break;
1241
1242         case EM_PARISC:
1243           rtype = elf_hppa_reloc_type (type);
1244           break;
1245
1246         case EM_H8_300:
1247         case EM_H8_300H:
1248         case EM_H8S:
1249           rtype = elf_h8_reloc_type (type);
1250           break;
1251
1252         case EM_OR1K:
1253           rtype = elf_or1k_reloc_type (type);
1254           break;
1255
1256         case EM_PJ:
1257         case EM_PJ_OLD:
1258           rtype = elf_pj_reloc_type (type);
1259           break;
1260         case EM_IA_64:
1261           rtype = elf_ia64_reloc_type (type);
1262           break;
1263
1264         case EM_CRIS:
1265           rtype = elf_cris_reloc_type (type);
1266           break;
1267
1268         case EM_860:
1269           rtype = elf_i860_reloc_type (type);
1270           break;
1271
1272         case EM_X86_64:
1273         case EM_L1OM:
1274         case EM_K1OM:
1275           rtype = elf_x86_64_reloc_type (type);
1276           break;
1277
1278         case EM_S370:
1279           rtype = i370_reloc_type (type);
1280           break;
1281
1282         case EM_S390_OLD:
1283         case EM_S390:
1284           rtype = elf_s390_reloc_type (type);
1285           break;
1286
1287         case EM_SCORE:
1288           rtype = elf_score_reloc_type (type);
1289           break;
1290
1291         case EM_XSTORMY16:
1292           rtype = elf_xstormy16_reloc_type (type);
1293           break;
1294
1295         case EM_CRX:
1296           rtype = elf_crx_reloc_type (type);
1297           break;
1298
1299         case EM_VAX:
1300           rtype = elf_vax_reloc_type (type);
1301           break;
1302
1303         case EM_ADAPTEVA_EPIPHANY:
1304           rtype = elf_epiphany_reloc_type (type);
1305           break;
1306
1307         case EM_IP2K:
1308         case EM_IP2K_OLD:
1309           rtype = elf_ip2k_reloc_type (type);
1310           break;
1311
1312         case EM_IQ2000:
1313           rtype = elf_iq2000_reloc_type (type);
1314           break;
1315
1316         case EM_XTENSA_OLD:
1317         case EM_XTENSA:
1318           rtype = elf_xtensa_reloc_type (type);
1319           break;
1320
1321         case EM_LATTICEMICO32:
1322           rtype = elf_lm32_reloc_type (type);
1323           break;
1324
1325         case EM_M32C_OLD:
1326         case EM_M32C:
1327           rtype = elf_m32c_reloc_type (type);
1328           break;
1329
1330         case EM_MT:
1331           rtype = elf_mt_reloc_type (type);
1332           break;
1333
1334         case EM_BLACKFIN:
1335           rtype = elf_bfin_reloc_type (type);
1336           break;
1337
1338         case EM_CYGNUS_MEP:
1339           rtype = elf_mep_reloc_type (type);
1340           break;
1341
1342         case EM_CR16:
1343           rtype = elf_cr16_reloc_type (type);
1344           break;
1345
1346         case EM_MICROBLAZE:
1347         case EM_MICROBLAZE_OLD:
1348           rtype = elf_microblaze_reloc_type (type);
1349           break;
1350
1351         case EM_RL78:
1352           rtype = elf_rl78_reloc_type (type);
1353           break;
1354
1355         case EM_RX:
1356           rtype = elf_rx_reloc_type (type);
1357           break;
1358
1359         case EM_METAG:
1360           rtype = elf_metag_reloc_type (type);
1361           break;
1362
1363         case EM_XC16X:
1364         case EM_C166:
1365           rtype = elf_xc16x_reloc_type (type);
1366           break;
1367
1368         case EM_TI_C6000:
1369           rtype = elf_tic6x_reloc_type (type);
1370           break;
1371
1372         case EM_TILEGX:
1373           rtype = elf_tilegx_reloc_type (type);
1374           break;
1375
1376         case EM_TILEPRO:
1377           rtype = elf_tilepro_reloc_type (type);
1378           break;
1379
1380         case EM_XGATE:
1381           rtype = elf_xgate_reloc_type (type);
1382           break;
1383
1384         case EM_ALTERA_NIOS2:
1385           rtype = elf_nios2_reloc_type (type);
1386           break;
1387         }
1388
1389       if (rtype == NULL)
1390         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1391       else
1392         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1393
1394       if (elf_header.e_machine == EM_ALPHA
1395           && rtype != NULL
1396           && streq (rtype, "R_ALPHA_LITUSE")
1397           && is_rela)
1398         {
1399           switch (rels[i].r_addend)
1400             {
1401             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1402             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1403             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1404             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1405             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1406             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1407             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1408             default: rtype = NULL;
1409             }
1410           if (rtype)
1411             printf (" (%s)", rtype);
1412           else
1413             {
1414               putchar (' ');
1415               printf (_("<unknown addend: %lx>"),
1416                       (unsigned long) rels[i].r_addend);
1417             }
1418         }
1419       else if (symtab_index)
1420         {
1421           if (symtab == NULL || symtab_index >= nsyms)
1422             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1423           else
1424             {
1425               Elf_Internal_Sym * psym;
1426
1427               psym = symtab + symtab_index;
1428
1429               printf (" ");
1430
1431               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1432                 {
1433                   const char * name;
1434                   unsigned int len;
1435                   unsigned int width = is_32bit_elf ? 8 : 14;
1436
1437                   /* Relocations against GNU_IFUNC symbols do not use the value
1438                      of the symbol as the address to relocate against.  Instead
1439                      they invoke the function named by the symbol and use its
1440                      result as the address for relocation.
1441
1442                      To indicate this to the user, do not display the value of
1443                      the symbol in the "Symbols's Value" field.  Instead show
1444                      its name followed by () as a hint that the symbol is
1445                      invoked.  */
1446
1447                   if (strtab == NULL
1448                       || psym->st_name == 0
1449                       || psym->st_name >= strtablen)
1450                     name = "??";
1451                   else
1452                     name = strtab + psym->st_name;
1453
1454                   len = print_symbol (width, name);
1455                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1456                 }
1457               else
1458                 {
1459                   print_vma (psym->st_value, LONG_HEX);
1460
1461                   printf (is_32bit_elf ? "   " : " ");
1462                 }
1463
1464               if (psym->st_name == 0)
1465                 {
1466                   const char * sec_name = "<null>";
1467                   char name_buf[40];
1468
1469                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1470                     {
1471                       if (psym->st_shndx < elf_header.e_shnum)
1472                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1473                       else if (psym->st_shndx == SHN_ABS)
1474                         sec_name = "ABS";
1475                       else if (psym->st_shndx == SHN_COMMON)
1476                         sec_name = "COMMON";
1477                       else if ((elf_header.e_machine == EM_MIPS
1478                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1479                                || (elf_header.e_machine == EM_TI_C6000
1480                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1481                         sec_name = "SCOMMON";
1482                       else if (elf_header.e_machine == EM_MIPS
1483                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1484                         sec_name = "SUNDEF";
1485                       else if ((elf_header.e_machine == EM_X86_64
1486                                 || elf_header.e_machine == EM_L1OM
1487                                 || elf_header.e_machine == EM_K1OM)
1488                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1489                         sec_name = "LARGE_COMMON";
1490                       else if (elf_header.e_machine == EM_IA_64
1491                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1492                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1493                         sec_name = "ANSI_COM";
1494                       else if (is_ia64_vms ()
1495                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1496                         sec_name = "VMS_SYMVEC";
1497                       else
1498                         {
1499                           sprintf (name_buf, "<section 0x%x>",
1500                                    (unsigned int) psym->st_shndx);
1501                           sec_name = name_buf;
1502                         }
1503                     }
1504                   print_symbol (22, sec_name);
1505                 }
1506               else if (strtab == NULL)
1507                 printf (_("<string table index: %3ld>"), psym->st_name);
1508               else if (psym->st_name >= strtablen)
1509                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1510               else
1511                 print_symbol (22, strtab + psym->st_name);
1512
1513               if (is_rela)
1514                 {
1515                   bfd_signed_vma off = rels[i].r_addend;
1516
1517                   if (off < 0)
1518                     printf (" - %" BFD_VMA_FMT "x", - off);
1519                   else
1520                     printf (" + %" BFD_VMA_FMT "x", off);
1521                 }
1522             }
1523         }
1524       else if (is_rela)
1525         {
1526           bfd_signed_vma off = rels[i].r_addend;
1527
1528           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1529           if (off < 0)
1530             printf ("-%" BFD_VMA_FMT "x", - off);
1531           else
1532             printf ("%" BFD_VMA_FMT "x", off);
1533         }
1534
1535       if (elf_header.e_machine == EM_SPARCV9
1536           && rtype != NULL
1537           && streq (rtype, "R_SPARC_OLO10"))
1538         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1539
1540       putchar ('\n');
1541
1542 #ifdef BFD64
1543       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1544         {
1545           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1546           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1547           const char * rtype2 = elf_mips_reloc_type (type2);
1548           const char * rtype3 = elf_mips_reloc_type (type3);
1549
1550           printf ("                    Type2: ");
1551
1552           if (rtype2 == NULL)
1553             printf (_("unrecognized: %-7lx"),
1554                     (unsigned long) type2 & 0xffffffff);
1555           else
1556             printf ("%-17.17s", rtype2);
1557
1558           printf ("\n                    Type3: ");
1559
1560           if (rtype3 == NULL)
1561             printf (_("unrecognized: %-7lx"),
1562                     (unsigned long) type3 & 0xffffffff);
1563           else
1564             printf ("%-17.17s", rtype3);
1565
1566           putchar ('\n');
1567         }
1568 #endif /* BFD64 */
1569     }
1570
1571   free (rels);
1572 }
1573
1574 static const char *
1575 get_mips_dynamic_type (unsigned long type)
1576 {
1577   switch (type)
1578     {
1579     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1580     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1581     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1582     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1583     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1584     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1585     case DT_MIPS_MSYM: return "MIPS_MSYM";
1586     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1587     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1588     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1589     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1590     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1591     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1592     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1593     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1594     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1595     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1596     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1597     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1598     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1599     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1600     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1601     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1602     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1603     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1604     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1605     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1606     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1607     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1608     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1609     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1610     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1611     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1612     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1613     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1614     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1615     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1616     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1617     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1618     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1619     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1620     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1621     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1622     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1623     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1624     default:
1625       return NULL;
1626     }
1627 }
1628
1629 static const char *
1630 get_sparc64_dynamic_type (unsigned long type)
1631 {
1632   switch (type)
1633     {
1634     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1635     default:
1636       return NULL;
1637     }
1638 }
1639
1640 static const char *
1641 get_ppc_dynamic_type (unsigned long type)
1642 {
1643   switch (type)
1644     {
1645     case DT_PPC_GOT:    return "PPC_GOT";
1646     case DT_PPC_OPT:    return "PPC_OPT";
1647     default:
1648       return NULL;
1649     }
1650 }
1651
1652 static const char *
1653 get_ppc64_dynamic_type (unsigned long type)
1654 {
1655   switch (type)
1656     {
1657     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1658     case DT_PPC64_OPD:    return "PPC64_OPD";
1659     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1660     case DT_PPC64_OPT:    return "PPC64_OPT";
1661     default:
1662       return NULL;
1663     }
1664 }
1665
1666 static const char *
1667 get_parisc_dynamic_type (unsigned long type)
1668 {
1669   switch (type)
1670     {
1671     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1672     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1673     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1674     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1675     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1676     case DT_HP_PREINIT:         return "HP_PREINIT";
1677     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1678     case DT_HP_NEEDED:          return "HP_NEEDED";
1679     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1680     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1681     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1682     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1683     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1684     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1685     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1686     case DT_HP_FILTERED:        return "HP_FILTERED";
1687     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1688     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1689     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1690     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1691     case DT_PLT:                return "PLT";
1692     case DT_PLT_SIZE:           return "PLT_SIZE";
1693     case DT_DLT:                return "DLT";
1694     case DT_DLT_SIZE:           return "DLT_SIZE";
1695     default:
1696       return NULL;
1697     }
1698 }
1699
1700 static const char *
1701 get_ia64_dynamic_type (unsigned long type)
1702 {
1703   switch (type)
1704     {
1705     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1706     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1707     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1708     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1709     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1710     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1711     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1712     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1713     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1714     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1715     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1716     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1717     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1718     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1719     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1720     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1721     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1722     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1723     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1724     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1725     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1726     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1727     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1728     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1729     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1730     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1731     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1732     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1733     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1734     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1735     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1736     default:
1737       return NULL;
1738     }
1739 }
1740
1741 static const char *
1742 get_alpha_dynamic_type (unsigned long type)
1743 {
1744   switch (type)
1745     {
1746     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1747     default:
1748       return NULL;
1749     }
1750 }
1751
1752 static const char *
1753 get_score_dynamic_type (unsigned long type)
1754 {
1755   switch (type)
1756     {
1757     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1758     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1759     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1760     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1761     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1762     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1763     default:
1764       return NULL;
1765     }
1766 }
1767
1768 static const char *
1769 get_tic6x_dynamic_type (unsigned long type)
1770 {
1771   switch (type)
1772     {
1773     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1774     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1775     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1776     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1777     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1778     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1779     default:
1780       return NULL;
1781     }
1782 }
1783
1784 static const char *
1785 get_nios2_dynamic_type (unsigned long type)
1786 {
1787   switch (type)
1788     {
1789     case DT_NIOS2_GP: return "NIOS2_GP";
1790     default:
1791       return NULL;
1792     }
1793 }
1794
1795 static const char *
1796 get_dynamic_type (unsigned long type)
1797 {
1798   static char buff[64];
1799
1800   switch (type)
1801     {
1802     case DT_NULL:       return "NULL";
1803     case DT_NEEDED:     return "NEEDED";
1804     case DT_PLTRELSZ:   return "PLTRELSZ";
1805     case DT_PLTGOT:     return "PLTGOT";
1806     case DT_HASH:       return "HASH";
1807     case DT_STRTAB:     return "STRTAB";
1808     case DT_SYMTAB:     return "SYMTAB";
1809     case DT_RELA:       return "RELA";
1810     case DT_RELASZ:     return "RELASZ";
1811     case DT_RELAENT:    return "RELAENT";
1812     case DT_STRSZ:      return "STRSZ";
1813     case DT_SYMENT:     return "SYMENT";
1814     case DT_INIT:       return "INIT";
1815     case DT_FINI:       return "FINI";
1816     case DT_SONAME:     return "SONAME";
1817     case DT_RPATH:      return "RPATH";
1818     case DT_SYMBOLIC:   return "SYMBOLIC";
1819     case DT_REL:        return "REL";
1820     case DT_RELSZ:      return "RELSZ";
1821     case DT_RELENT:     return "RELENT";
1822     case DT_PLTREL:     return "PLTREL";
1823     case DT_DEBUG:      return "DEBUG";
1824     case DT_TEXTREL:    return "TEXTREL";
1825     case DT_JMPREL:     return "JMPREL";
1826     case DT_BIND_NOW:   return "BIND_NOW";
1827     case DT_INIT_ARRAY: return "INIT_ARRAY";
1828     case DT_FINI_ARRAY: return "FINI_ARRAY";
1829     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1830     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1831     case DT_RUNPATH:    return "RUNPATH";
1832     case DT_FLAGS:      return "FLAGS";
1833
1834     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1835     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1836
1837     case DT_CHECKSUM:   return "CHECKSUM";
1838     case DT_PLTPADSZ:   return "PLTPADSZ";
1839     case DT_MOVEENT:    return "MOVEENT";
1840     case DT_MOVESZ:     return "MOVESZ";
1841     case DT_FEATURE:    return "FEATURE";
1842     case DT_POSFLAG_1:  return "POSFLAG_1";
1843     case DT_SYMINSZ:    return "SYMINSZ";
1844     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1845
1846     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1847     case DT_CONFIG:     return "CONFIG";
1848     case DT_DEPAUDIT:   return "DEPAUDIT";
1849     case DT_AUDIT:      return "AUDIT";
1850     case DT_PLTPAD:     return "PLTPAD";
1851     case DT_MOVETAB:    return "MOVETAB";
1852     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1853
1854     case DT_VERSYM:     return "VERSYM";
1855
1856     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1857     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1858     case DT_RELACOUNT:  return "RELACOUNT";
1859     case DT_RELCOUNT:   return "RELCOUNT";
1860     case DT_FLAGS_1:    return "FLAGS_1";
1861     case DT_VERDEF:     return "VERDEF";
1862     case DT_VERDEFNUM:  return "VERDEFNUM";
1863     case DT_VERNEED:    return "VERNEED";
1864     case DT_VERNEEDNUM: return "VERNEEDNUM";
1865
1866     case DT_AUXILIARY:  return "AUXILIARY";
1867     case DT_USED:       return "USED";
1868     case DT_FILTER:     return "FILTER";
1869
1870     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1871     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1872     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1873     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1874     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1875     case DT_GNU_HASH:   return "GNU_HASH";
1876
1877     default:
1878       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1879         {
1880           const char * result;
1881
1882           switch (elf_header.e_machine)
1883             {
1884             case EM_MIPS:
1885             case EM_MIPS_RS3_LE:
1886               result = get_mips_dynamic_type (type);
1887               break;
1888             case EM_SPARCV9:
1889               result = get_sparc64_dynamic_type (type);
1890               break;
1891             case EM_PPC:
1892               result = get_ppc_dynamic_type (type);
1893               break;
1894             case EM_PPC64:
1895               result = get_ppc64_dynamic_type (type);
1896               break;
1897             case EM_IA_64:
1898               result = get_ia64_dynamic_type (type);
1899               break;
1900             case EM_ALPHA:
1901               result = get_alpha_dynamic_type (type);
1902               break;
1903             case EM_SCORE:
1904               result = get_score_dynamic_type (type);
1905               break;
1906             case EM_TI_C6000:
1907               result = get_tic6x_dynamic_type (type);
1908               break;
1909             case EM_ALTERA_NIOS2:
1910               result = get_nios2_dynamic_type (type);
1911               break;
1912             default:
1913               result = NULL;
1914               break;
1915             }
1916
1917           if (result != NULL)
1918             return result;
1919
1920           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1921         }
1922       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1923                || (elf_header.e_machine == EM_PARISC
1924                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1925         {
1926           const char * result;
1927
1928           switch (elf_header.e_machine)
1929             {
1930             case EM_PARISC:
1931               result = get_parisc_dynamic_type (type);
1932               break;
1933             case EM_IA_64:
1934               result = get_ia64_dynamic_type (type);
1935               break;
1936             default:
1937               result = NULL;
1938               break;
1939             }
1940
1941           if (result != NULL)
1942             return result;
1943
1944           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1945                     type);
1946         }
1947       else
1948         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1949
1950       return buff;
1951     }
1952 }
1953
1954 static char *
1955 get_file_type (unsigned e_type)
1956 {
1957   static char buff[32];
1958
1959   switch (e_type)
1960     {
1961     case ET_NONE:       return _("NONE (None)");
1962     case ET_REL:        return _("REL (Relocatable file)");
1963     case ET_EXEC:       return _("EXEC (Executable file)");
1964     case ET_DYN:        return _("DYN (Shared object file)");
1965     case ET_CORE:       return _("CORE (Core file)");
1966
1967     default:
1968       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1969         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1970       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1971         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1972       else
1973         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1974       return buff;
1975     }
1976 }
1977
1978 static char *
1979 get_machine_name (unsigned e_machine)
1980 {
1981   static char buff[64]; /* XXX */
1982
1983   switch (e_machine)
1984     {
1985     case EM_NONE:               return _("None");
1986     case EM_AARCH64:            return "AArch64";
1987     case EM_M32:                return "WE32100";
1988     case EM_SPARC:              return "Sparc";
1989     case EM_SPU:                return "SPU";
1990     case EM_386:                return "Intel 80386";
1991     case EM_68K:                return "MC68000";
1992     case EM_88K:                return "MC88000";
1993     case EM_486:                return "Intel 80486";
1994     case EM_860:                return "Intel 80860";
1995     case EM_MIPS:               return "MIPS R3000";
1996     case EM_S370:               return "IBM System/370";
1997     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1998     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1999     case EM_PARISC:             return "HPPA";
2000     case EM_PPC_OLD:            return "Power PC (old)";
2001     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2002     case EM_960:                return "Intel 90860";
2003     case EM_PPC:                return "PowerPC";
2004     case EM_PPC64:              return "PowerPC64";
2005     case EM_FR20:               return "Fujitsu FR20";
2006     case EM_RH32:               return "TRW RH32";
2007     case EM_MCORE:              return "MCORE";
2008     case EM_ARM:                return "ARM";
2009     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2010     case EM_SH:                 return "Renesas / SuperH SH";
2011     case EM_SPARCV9:            return "Sparc v9";
2012     case EM_TRICORE:            return "Siemens Tricore";
2013     case EM_ARC:                return "ARC";
2014     case EM_H8_300:             return "Renesas H8/300";
2015     case EM_H8_300H:            return "Renesas H8/300H";
2016     case EM_H8S:                return "Renesas H8S";
2017     case EM_H8_500:             return "Renesas H8/500";
2018     case EM_IA_64:              return "Intel IA-64";
2019     case EM_MIPS_X:             return "Stanford MIPS-X";
2020     case EM_COLDFIRE:           return "Motorola Coldfire";
2021     case EM_ALPHA:              return "Alpha";
2022     case EM_CYGNUS_D10V:
2023     case EM_D10V:               return "d10v";
2024     case EM_CYGNUS_D30V:
2025     case EM_D30V:               return "d30v";
2026     case EM_CYGNUS_M32R:
2027     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2028     case EM_CYGNUS_V850:
2029     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2030     case EM_V850:               return "Renesas V850";
2031     case EM_CYGNUS_MN10300:
2032     case EM_MN10300:            return "mn10300";
2033     case EM_CYGNUS_MN10200:
2034     case EM_MN10200:            return "mn10200";
2035     case EM_MOXIE:              return "Moxie";
2036     case EM_CYGNUS_FR30:
2037     case EM_FR30:               return "Fujitsu FR30";
2038     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2039     case EM_PJ_OLD:
2040     case EM_PJ:                 return "picoJava";
2041     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2042     case EM_PCP:                return "Siemens PCP";
2043     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2044     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2045     case EM_STARCORE:           return "Motorola Star*Core processor";
2046     case EM_ME16:               return "Toyota ME16 processor";
2047     case EM_ST100:              return "STMicroelectronics ST100 processor";
2048     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2049     case EM_PDSP:               return "Sony DSP processor";
2050     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2051     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2052     case EM_FX66:               return "Siemens FX66 microcontroller";
2053     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2054     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2055     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2056     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2057     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2058     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2059     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2060     case EM_SVX:                return "Silicon Graphics SVx";
2061     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2062     case EM_VAX:                return "Digital VAX";
2063     case EM_AVR_OLD:
2064     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2065     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2066     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2067     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2068     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2069     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2070     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2071     case EM_PRISM:              return "Vitesse Prism";
2072     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2073     case EM_L1OM:               return "Intel L1OM";
2074     case EM_K1OM:               return "Intel K1OM";
2075     case EM_S390_OLD:
2076     case EM_S390:               return "IBM S/390";
2077     case EM_SCORE:              return "SUNPLUS S+Core";
2078     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2079     case EM_OR1K:               return "OpenRISC 1000";
2080     case EM_ARC_A5:             return "ARC International ARCompact processor";
2081     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2082     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2083     case EM_DLX:                return "OpenDLX";
2084     case EM_IP2K_OLD:
2085     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2086     case EM_IQ2000:             return "Vitesse IQ2000";
2087     case EM_XTENSA_OLD:
2088     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2089     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2090     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2091     case EM_NS32K:              return "National Semiconductor 32000 series";
2092     case EM_TPC:                return "Tenor Network TPC processor";
2093     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2094     case EM_MAX:                return "MAX Processor";
2095     case EM_CR:                 return "National Semiconductor CompactRISC";
2096     case EM_F2MC16:             return "Fujitsu F2MC16";
2097     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2098     case EM_LATTICEMICO32:      return "Lattice Mico32";
2099     case EM_M32C_OLD:
2100     case EM_M32C:               return "Renesas M32c";
2101     case EM_MT:                 return "Morpho Techologies MT processor";
2102     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2103     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2104     case EM_SEP:                return "Sharp embedded microprocessor";
2105     case EM_ARCA:               return "Arca RISC microprocessor";
2106     case EM_UNICORE:            return "Unicore";
2107     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2108     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2109     case EM_NIOS32:             return "Altera Nios";
2110     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2111     case EM_C166:
2112     case EM_XC16X:              return "Infineon Technologies xc16x";
2113     case EM_M16C:               return "Renesas M16C series microprocessors";
2114     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2115     case EM_CE:                 return "Freescale Communication Engine RISC core";
2116     case EM_TSK3000:            return "Altium TSK3000 core";
2117     case EM_RS08:               return "Freescale RS08 embedded processor";
2118     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2119     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2120     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2121     case EM_SE_C17:             return "Seiko Epson C17 family";
2122     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2123     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2124     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2125     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2126     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2127     case EM_R32C:               return "Renesas R32C series microprocessors";
2128     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2129     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2130     case EM_8051:               return "Intel 8051 and variants";
2131     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2132     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2133     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2134     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2135     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2136     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2137     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2138     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2139     case EM_CR16:
2140     case EM_MICROBLAZE:
2141     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2142     case EM_RL78:               return "Renesas RL78";
2143     case EM_RX:                 return "Renesas RX";
2144     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2145     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2146     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2147     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2148     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2149     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2150     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2151     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2152     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2153     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2154     case EM_CUDA:               return "NVIDIA CUDA architecture";
2155     case EM_XGATE:              return "Motorola XGATE embedded processor";
2156     default:
2157       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2158       return buff;
2159     }
2160 }
2161
2162 static void
2163 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2164 {
2165   unsigned eabi;
2166   int unknown = 0;
2167
2168   eabi = EF_ARM_EABI_VERSION (e_flags);
2169   e_flags &= ~ EF_ARM_EABIMASK;
2170
2171   /* Handle "generic" ARM flags.  */
2172   if (e_flags & EF_ARM_RELEXEC)
2173     {
2174       strcat (buf, ", relocatable executable");
2175       e_flags &= ~ EF_ARM_RELEXEC;
2176     }
2177
2178   if (e_flags & EF_ARM_HASENTRY)
2179     {
2180       strcat (buf, ", has entry point");
2181       e_flags &= ~ EF_ARM_HASENTRY;
2182     }
2183
2184   /* Now handle EABI specific flags.  */
2185   switch (eabi)
2186     {
2187     default:
2188       strcat (buf, ", <unrecognized EABI>");
2189       if (e_flags)
2190         unknown = 1;
2191       break;
2192
2193     case EF_ARM_EABI_VER1:
2194       strcat (buf, ", Version1 EABI");
2195       while (e_flags)
2196         {
2197           unsigned flag;
2198
2199           /* Process flags one bit at a time.  */
2200           flag = e_flags & - e_flags;
2201           e_flags &= ~ flag;
2202
2203           switch (flag)
2204             {
2205             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2206               strcat (buf, ", sorted symbol tables");
2207               break;
2208
2209             default:
2210               unknown = 1;
2211               break;
2212             }
2213         }
2214       break;
2215
2216     case EF_ARM_EABI_VER2:
2217       strcat (buf, ", Version2 EABI");
2218       while (e_flags)
2219         {
2220           unsigned flag;
2221
2222           /* Process flags one bit at a time.  */
2223           flag = e_flags & - e_flags;
2224           e_flags &= ~ flag;
2225
2226           switch (flag)
2227             {
2228             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2229               strcat (buf, ", sorted symbol tables");
2230               break;
2231
2232             case EF_ARM_DYNSYMSUSESEGIDX:
2233               strcat (buf, ", dynamic symbols use segment index");
2234               break;
2235
2236             case EF_ARM_MAPSYMSFIRST:
2237               strcat (buf, ", mapping symbols precede others");
2238               break;
2239
2240             default:
2241               unknown = 1;
2242               break;
2243             }
2244         }
2245       break;
2246
2247     case EF_ARM_EABI_VER3:
2248       strcat (buf, ", Version3 EABI");
2249       break;
2250
2251     case EF_ARM_EABI_VER4:
2252       strcat (buf, ", Version4 EABI");
2253       while (e_flags)
2254         {
2255           unsigned flag;
2256
2257           /* Process flags one bit at a time.  */
2258           flag = e_flags & - e_flags;
2259           e_flags &= ~ flag;
2260
2261           switch (flag)
2262             {
2263             case EF_ARM_BE8:
2264               strcat (buf, ", BE8");
2265               break;
2266
2267             case EF_ARM_LE8:
2268               strcat (buf, ", LE8");
2269               break;
2270
2271             default:
2272               unknown = 1;
2273               break;
2274             }
2275       break;
2276         }
2277       break;
2278
2279     case EF_ARM_EABI_VER5:
2280       strcat (buf, ", Version5 EABI");
2281       while (e_flags)
2282         {
2283           unsigned flag;
2284
2285           /* Process flags one bit at a time.  */
2286           flag = e_flags & - e_flags;
2287           e_flags &= ~ flag;
2288
2289           switch (flag)
2290             {
2291             case EF_ARM_BE8:
2292               strcat (buf, ", BE8");
2293               break;
2294
2295             case EF_ARM_LE8:
2296               strcat (buf, ", LE8");
2297               break;
2298
2299             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2300               strcat (buf, ", soft-float ABI");
2301               break;
2302
2303             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2304               strcat (buf, ", hard-float ABI");
2305               break;
2306
2307             default:
2308               unknown = 1;
2309               break;
2310             }
2311         }
2312       break;
2313
2314     case EF_ARM_EABI_UNKNOWN:
2315       strcat (buf, ", GNU EABI");
2316       while (e_flags)
2317         {
2318           unsigned flag;
2319
2320           /* Process flags one bit at a time.  */
2321           flag = e_flags & - e_flags;
2322           e_flags &= ~ flag;
2323
2324           switch (flag)
2325             {
2326             case EF_ARM_INTERWORK:
2327               strcat (buf, ", interworking enabled");
2328               break;
2329
2330             case EF_ARM_APCS_26:
2331               strcat (buf, ", uses APCS/26");
2332               break;
2333
2334             case EF_ARM_APCS_FLOAT:
2335               strcat (buf, ", uses APCS/float");
2336               break;
2337
2338             case EF_ARM_PIC:
2339               strcat (buf, ", position independent");
2340               break;
2341
2342             case EF_ARM_ALIGN8:
2343               strcat (buf, ", 8 bit structure alignment");
2344               break;
2345
2346             case EF_ARM_NEW_ABI:
2347               strcat (buf, ", uses new ABI");
2348               break;
2349
2350             case EF_ARM_OLD_ABI:
2351               strcat (buf, ", uses old ABI");
2352               break;
2353
2354             case EF_ARM_SOFT_FLOAT:
2355               strcat (buf, ", software FP");
2356               break;
2357
2358             case EF_ARM_VFP_FLOAT:
2359               strcat (buf, ", VFP");
2360               break;
2361
2362             case EF_ARM_MAVERICK_FLOAT:
2363               strcat (buf, ", Maverick FP");
2364               break;
2365
2366             default:
2367               unknown = 1;
2368               break;
2369             }
2370         }
2371     }
2372
2373   if (unknown)
2374     strcat (buf,_(", <unknown>"));
2375 }
2376
2377 static void
2378 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2379 {
2380   unsigned abi;
2381   unsigned arch;
2382   unsigned config;
2383   unsigned version;
2384   int has_fpu = 0;
2385   int r = 0;
2386
2387   static const char *ABI_STRINGS[] =
2388   {
2389     "ABI v0", /* use r5 as return register; only used in N1213HC */
2390     "ABI v1", /* use r0 as return register */
2391     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2392     "ABI v2fp", /* for FPU */
2393     "AABI",
2394     "ABI2 FP+"
2395   };
2396   static const char *VER_STRINGS[] =
2397   {
2398     "Andes ELF V1.3 or older",
2399     "Andes ELF V1.3.1",
2400     "Andes ELF V1.4"
2401   };
2402   static const char *ARCH_STRINGS[] =
2403   {
2404     "",
2405     "Andes Star v1.0",
2406     "Andes Star v2.0",
2407     "Andes Star v3.0",
2408     "Andes Star v3.0m"
2409   };
2410
2411   abi = EF_NDS_ABI & e_flags;
2412   arch = EF_NDS_ARCH & e_flags;
2413   config = EF_NDS_INST & e_flags;
2414   version = EF_NDS32_ELF_VERSION & e_flags;
2415
2416   memset (buf, 0, size);
2417
2418   switch (abi)
2419     {
2420     case E_NDS_ABI_V0:
2421     case E_NDS_ABI_V1:
2422     case E_NDS_ABI_V2:
2423     case E_NDS_ABI_V2FP:
2424     case E_NDS_ABI_AABI:
2425     case E_NDS_ABI_V2FP_PLUS:
2426       /* In case there are holes in the array.  */
2427       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2428       break;
2429
2430     default:
2431       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2432       break;
2433     }
2434
2435   switch (version)
2436     {
2437     case E_NDS32_ELF_VER_1_2:
2438     case E_NDS32_ELF_VER_1_3:
2439     case E_NDS32_ELF_VER_1_4:
2440       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2441       break;
2442
2443     default:
2444       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2445       break;
2446     }
2447
2448   if (E_NDS_ABI_V0 == abi)
2449     {
2450       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2451       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2452       if (arch == E_NDS_ARCH_STAR_V1_0)
2453         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2454       return;
2455     }
2456
2457   switch (arch)
2458     {
2459     case E_NDS_ARCH_STAR_V1_0:
2460     case E_NDS_ARCH_STAR_V2_0:
2461     case E_NDS_ARCH_STAR_V3_0:
2462     case E_NDS_ARCH_STAR_V3_M:
2463       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2464       break;
2465
2466     default:
2467       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2468       /* ARCH version determines how the e_flags are interpreted.
2469          If it is unknown, we cannot proceed.  */
2470       return;
2471     }
2472
2473   /* Newer ABI; Now handle architecture specific flags.  */
2474   if (arch == E_NDS_ARCH_STAR_V1_0)
2475     {
2476       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2477         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2478
2479       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2480         r += snprintf (buf + r, size -r, ", MAC");
2481
2482       if (config & E_NDS32_HAS_DIV_INST)
2483         r += snprintf (buf + r, size -r, ", DIV");
2484
2485       if (config & E_NDS32_HAS_16BIT_INST)
2486         r += snprintf (buf + r, size -r, ", 16b");
2487     }
2488   else
2489     {
2490       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2491         {
2492           if (version <= E_NDS32_ELF_VER_1_3)
2493             r += snprintf (buf + r, size -r, ", [B8]");
2494           else
2495             r += snprintf (buf + r, size -r, ", EX9");
2496         }
2497
2498       if (config & E_NDS32_HAS_MAC_DX_INST)
2499         r += snprintf (buf + r, size -r, ", MAC_DX");
2500
2501       if (config & E_NDS32_HAS_DIV_DX_INST)
2502         r += snprintf (buf + r, size -r, ", DIV_DX");
2503
2504       if (config & E_NDS32_HAS_16BIT_INST)
2505         {
2506           if (version <= E_NDS32_ELF_VER_1_3)
2507             r += snprintf (buf + r, size -r, ", 16b");
2508           else
2509             r += snprintf (buf + r, size -r, ", IFC");
2510         }
2511     }
2512
2513   if (config & E_NDS32_HAS_EXT_INST)
2514     r += snprintf (buf + r, size -r, ", PERF1");
2515
2516   if (config & E_NDS32_HAS_EXT2_INST)
2517     r += snprintf (buf + r, size -r, ", PERF2");
2518
2519   if (config & E_NDS32_HAS_FPU_INST)
2520     {
2521       has_fpu = 1;
2522       r += snprintf (buf + r, size -r, ", FPU_SP");
2523     }
2524
2525   if (config & E_NDS32_HAS_FPU_DP_INST)
2526     {
2527       has_fpu = 1;
2528       r += snprintf (buf + r, size -r, ", FPU_DP");
2529     }
2530
2531   if (config & E_NDS32_HAS_FPU_MAC_INST)
2532     {
2533       has_fpu = 1;
2534       r += snprintf (buf + r, size -r, ", FPU_MAC");
2535     }
2536
2537   if (has_fpu)
2538     {
2539       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2540         {
2541         case E_NDS32_FPU_REG_8SP_4DP:
2542           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2543           break;
2544         case E_NDS32_FPU_REG_16SP_8DP:
2545           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2546           break;
2547         case E_NDS32_FPU_REG_32SP_16DP:
2548           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2549           break;
2550         case E_NDS32_FPU_REG_32SP_32DP:
2551           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2552           break;
2553         }
2554     }
2555
2556   if (config & E_NDS32_HAS_AUDIO_INST)
2557     r += snprintf (buf + r, size -r, ", AUDIO");
2558
2559   if (config & E_NDS32_HAS_STRING_INST)
2560     r += snprintf (buf + r, size -r, ", STR");
2561
2562   if (config & E_NDS32_HAS_REDUCED_REGS)
2563     r += snprintf (buf + r, size -r, ", 16REG");
2564
2565   if (config & E_NDS32_HAS_VIDEO_INST)
2566     {
2567       if (version <= E_NDS32_ELF_VER_1_3)
2568         r += snprintf (buf + r, size -r, ", VIDEO");
2569       else
2570         r += snprintf (buf + r, size -r, ", SATURATION");
2571     }
2572
2573   if (config & E_NDS32_HAS_ENCRIPT_INST)
2574     r += snprintf (buf + r, size -r, ", ENCRP");
2575
2576   if (config & E_NDS32_HAS_L2C_INST)
2577     r += snprintf (buf + r, size -r, ", L2C");
2578 }
2579
2580 static char *
2581 get_machine_flags (unsigned e_flags, unsigned e_machine)
2582 {
2583   static char buf[1024];
2584
2585   buf[0] = '\0';
2586
2587   if (e_flags)
2588     {
2589       switch (e_machine)
2590         {
2591         default:
2592           break;
2593
2594         case EM_ARM:
2595           decode_ARM_machine_flags (e_flags, buf);
2596           break;
2597
2598         case EM_BLACKFIN:
2599           if (e_flags & EF_BFIN_PIC)
2600             strcat (buf, ", PIC");
2601
2602           if (e_flags & EF_BFIN_FDPIC)
2603             strcat (buf, ", FDPIC");
2604
2605           if (e_flags & EF_BFIN_CODE_IN_L1)
2606             strcat (buf, ", code in L1");
2607
2608           if (e_flags & EF_BFIN_DATA_IN_L1)
2609             strcat (buf, ", data in L1");
2610
2611           break;
2612
2613         case EM_CYGNUS_FRV:
2614           switch (e_flags & EF_FRV_CPU_MASK)
2615             {
2616             case EF_FRV_CPU_GENERIC:
2617               break;
2618
2619             default:
2620               strcat (buf, ", fr???");
2621               break;
2622
2623             case EF_FRV_CPU_FR300:
2624               strcat (buf, ", fr300");
2625               break;
2626
2627             case EF_FRV_CPU_FR400:
2628               strcat (buf, ", fr400");
2629               break;
2630             case EF_FRV_CPU_FR405:
2631               strcat (buf, ", fr405");
2632               break;
2633
2634             case EF_FRV_CPU_FR450:
2635               strcat (buf, ", fr450");
2636               break;
2637
2638             case EF_FRV_CPU_FR500:
2639               strcat (buf, ", fr500");
2640               break;
2641             case EF_FRV_CPU_FR550:
2642               strcat (buf, ", fr550");
2643               break;
2644
2645             case EF_FRV_CPU_SIMPLE:
2646               strcat (buf, ", simple");
2647               break;
2648             case EF_FRV_CPU_TOMCAT:
2649               strcat (buf, ", tomcat");
2650               break;
2651             }
2652           break;
2653
2654         case EM_68K:
2655           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2656             strcat (buf, ", m68000");
2657           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2658             strcat (buf, ", cpu32");
2659           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2660             strcat (buf, ", fido_a");
2661           else
2662             {
2663               char const * isa = _("unknown");
2664               char const * mac = _("unknown mac");
2665               char const * additional = NULL;
2666
2667               switch (e_flags & EF_M68K_CF_ISA_MASK)
2668                 {
2669                 case EF_M68K_CF_ISA_A_NODIV:
2670                   isa = "A";
2671                   additional = ", nodiv";
2672                   break;
2673                 case EF_M68K_CF_ISA_A:
2674                   isa = "A";
2675                   break;
2676                 case EF_M68K_CF_ISA_A_PLUS:
2677                   isa = "A+";
2678                   break;
2679                 case EF_M68K_CF_ISA_B_NOUSP:
2680                   isa = "B";
2681                   additional = ", nousp";
2682                   break;
2683                 case EF_M68K_CF_ISA_B:
2684                   isa = "B";
2685                   break;
2686                 case EF_M68K_CF_ISA_C:
2687                   isa = "C";
2688                   break;
2689                 case EF_M68K_CF_ISA_C_NODIV:
2690                   isa = "C";
2691                   additional = ", nodiv";
2692                   break;
2693                 }
2694               strcat (buf, ", cf, isa ");
2695               strcat (buf, isa);
2696               if (additional)
2697                 strcat (buf, additional);
2698               if (e_flags & EF_M68K_CF_FLOAT)
2699                 strcat (buf, ", float");
2700               switch (e_flags & EF_M68K_CF_MAC_MASK)
2701                 {
2702                 case 0:
2703                   mac = NULL;
2704                   break;
2705                 case EF_M68K_CF_MAC:
2706                   mac = "mac";
2707                   break;
2708                 case EF_M68K_CF_EMAC:
2709                   mac = "emac";
2710                   break;
2711                 case EF_M68K_CF_EMAC_B:
2712                   mac = "emac_b";
2713                   break;
2714                 }
2715               if (mac)
2716                 {
2717                   strcat (buf, ", ");
2718                   strcat (buf, mac);
2719                 }
2720             }
2721           break;
2722
2723         case EM_PPC:
2724           if (e_flags & EF_PPC_EMB)
2725             strcat (buf, ", emb");
2726
2727           if (e_flags & EF_PPC_RELOCATABLE)
2728             strcat (buf, _(", relocatable"));
2729
2730           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2731             strcat (buf, _(", relocatable-lib"));
2732           break;
2733
2734         case EM_PPC64:
2735           if (e_flags & EF_PPC64_ABI)
2736             {
2737               char abi[] = ", abiv0";
2738
2739               abi[6] += e_flags & EF_PPC64_ABI;
2740               strcat (buf, abi);
2741             }
2742           break;
2743
2744         case EM_V800:
2745           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2746             strcat (buf, ", RH850 ABI");
2747
2748           if (e_flags & EF_V800_850E3)
2749             strcat (buf, ", V3 architecture");
2750
2751           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2752             strcat (buf, ", FPU not used");
2753
2754           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2755             strcat (buf, ", regmode: COMMON");
2756
2757           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2758             strcat (buf, ", r4 not used");
2759
2760           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2761             strcat (buf, ", r30 not used");
2762
2763           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2764             strcat (buf, ", r5 not used");
2765
2766           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2767             strcat (buf, ", r2 not used");
2768
2769           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2770             {
2771               switch (e_flags & - e_flags)
2772                 {
2773                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2774                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2775                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2776                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2777                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2778                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2779                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2780                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2781                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2782                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2783                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2784                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2785                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2786                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2787                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2788                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2789                 default: break;
2790                 }
2791             }
2792           break;
2793
2794         case EM_V850:
2795         case EM_CYGNUS_V850:
2796           switch (e_flags & EF_V850_ARCH)
2797             {
2798             case E_V850E3V5_ARCH:
2799               strcat (buf, ", v850e3v5");
2800               break;
2801             case E_V850E2V3_ARCH:
2802               strcat (buf, ", v850e2v3");
2803               break;
2804             case E_V850E2_ARCH:
2805               strcat (buf, ", v850e2");
2806               break;
2807             case E_V850E1_ARCH:
2808               strcat (buf, ", v850e1");
2809               break;
2810             case E_V850E_ARCH:
2811               strcat (buf, ", v850e");
2812               break;
2813             case E_V850_ARCH:
2814               strcat (buf, ", v850");
2815               break;
2816             default:
2817               strcat (buf, _(", unknown v850 architecture variant"));
2818               break;
2819             }
2820           break;
2821
2822         case EM_M32R:
2823         case EM_CYGNUS_M32R:
2824           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2825             strcat (buf, ", m32r");
2826           break;
2827
2828         case EM_MIPS:
2829         case EM_MIPS_RS3_LE:
2830           if (e_flags & EF_MIPS_NOREORDER)
2831             strcat (buf, ", noreorder");
2832
2833           if (e_flags & EF_MIPS_PIC)
2834             strcat (buf, ", pic");
2835
2836           if (e_flags & EF_MIPS_CPIC)
2837             strcat (buf, ", cpic");
2838
2839           if (e_flags & EF_MIPS_UCODE)
2840             strcat (buf, ", ugen_reserved");
2841
2842           if (e_flags & EF_MIPS_ABI2)
2843             strcat (buf, ", abi2");
2844
2845           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2846             strcat (buf, ", odk first");
2847
2848           if (e_flags & EF_MIPS_32BITMODE)
2849             strcat (buf, ", 32bitmode");
2850
2851           if (e_flags & EF_MIPS_NAN2008)
2852             strcat (buf, ", nan2008");
2853
2854           if (e_flags & EF_MIPS_FP64)
2855             strcat (buf, ", fp64");
2856
2857           switch ((e_flags & EF_MIPS_MACH))
2858             {
2859             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2860             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2861             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2862             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2863             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2864             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2865             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2866             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2867             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2868             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2869             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2870             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2871             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2872             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2873             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2874             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2875             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2876             case 0:
2877             /* We simply ignore the field in this case to avoid confusion:
2878                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2879                extension.  */
2880               break;
2881             default: strcat (buf, _(", unknown CPU")); break;
2882             }
2883
2884           switch ((e_flags & EF_MIPS_ABI))
2885             {
2886             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2887             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2888             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2889             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2890             case 0:
2891             /* We simply ignore the field in this case to avoid confusion:
2892                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2893                This means it is likely to be an o32 file, but not for
2894                sure.  */
2895               break;
2896             default: strcat (buf, _(", unknown ABI")); break;
2897             }
2898
2899           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2900             strcat (buf, ", mdmx");
2901
2902           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2903             strcat (buf, ", mips16");
2904
2905           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2906             strcat (buf, ", micromips");
2907
2908           switch ((e_flags & EF_MIPS_ARCH))
2909             {
2910             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2911             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2912             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2913             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2914             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2915             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2916             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2917             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
2918             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2919             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2920             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2921             default: strcat (buf, _(", unknown ISA")); break;
2922             }
2923           break;
2924
2925         case EM_NDS32:
2926           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2927           break;
2928
2929         case EM_SH:
2930           switch ((e_flags & EF_SH_MACH_MASK))
2931             {
2932             case EF_SH1: strcat (buf, ", sh1"); break;
2933             case EF_SH2: strcat (buf, ", sh2"); break;
2934             case EF_SH3: strcat (buf, ", sh3"); break;
2935             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2936             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2937             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2938             case EF_SH3E: strcat (buf, ", sh3e"); break;
2939             case EF_SH4: strcat (buf, ", sh4"); break;
2940             case EF_SH5: strcat (buf, ", sh5"); break;
2941             case EF_SH2E: strcat (buf, ", sh2e"); break;
2942             case EF_SH4A: strcat (buf, ", sh4a"); break;
2943             case EF_SH2A: strcat (buf, ", sh2a"); break;
2944             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2945             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2946             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2947             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2948             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2949             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2950             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2951             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2952             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2953             default: strcat (buf, _(", unknown ISA")); break;
2954             }
2955
2956           if (e_flags & EF_SH_PIC)
2957             strcat (buf, ", pic");
2958
2959           if (e_flags & EF_SH_FDPIC)
2960             strcat (buf, ", fdpic");
2961           break;
2962
2963         case EM_OR1K:
2964           if (e_flags & EF_OR1K_NODELAY)
2965             strcat (buf, ", no delay");
2966           break;
2967
2968         case EM_SPARCV9:
2969           if (e_flags & EF_SPARC_32PLUS)
2970             strcat (buf, ", v8+");
2971
2972           if (e_flags & EF_SPARC_SUN_US1)
2973             strcat (buf, ", ultrasparcI");
2974
2975           if (e_flags & EF_SPARC_SUN_US3)
2976             strcat (buf, ", ultrasparcIII");
2977
2978           if (e_flags & EF_SPARC_HAL_R1)
2979             strcat (buf, ", halr1");
2980
2981           if (e_flags & EF_SPARC_LEDATA)
2982             strcat (buf, ", ledata");
2983
2984           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2985             strcat (buf, ", tso");
2986
2987           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2988             strcat (buf, ", pso");
2989
2990           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2991             strcat (buf, ", rmo");
2992           break;
2993
2994         case EM_PARISC:
2995           switch (e_flags & EF_PARISC_ARCH)
2996             {
2997             case EFA_PARISC_1_0:
2998               strcpy (buf, ", PA-RISC 1.0");
2999               break;
3000             case EFA_PARISC_1_1:
3001               strcpy (buf, ", PA-RISC 1.1");
3002               break;
3003             case EFA_PARISC_2_0:
3004               strcpy (buf, ", PA-RISC 2.0");
3005               break;
3006             default:
3007               break;
3008             }
3009           if (e_flags & EF_PARISC_TRAPNIL)
3010             strcat (buf, ", trapnil");
3011           if (e_flags & EF_PARISC_EXT)
3012             strcat (buf, ", ext");
3013           if (e_flags & EF_PARISC_LSB)
3014             strcat (buf, ", lsb");
3015           if (e_flags & EF_PARISC_WIDE)
3016             strcat (buf, ", wide");
3017           if (e_flags & EF_PARISC_NO_KABP)
3018             strcat (buf, ", no kabp");
3019           if (e_flags & EF_PARISC_LAZYSWAP)
3020             strcat (buf, ", lazyswap");
3021           break;
3022
3023         case EM_PJ:
3024         case EM_PJ_OLD:
3025           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3026             strcat (buf, ", new calling convention");
3027
3028           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3029             strcat (buf, ", gnu calling convention");
3030           break;
3031
3032         case EM_IA_64:
3033           if ((e_flags & EF_IA_64_ABI64))
3034             strcat (buf, ", 64-bit");
3035           else
3036             strcat (buf, ", 32-bit");
3037           if ((e_flags & EF_IA_64_REDUCEDFP))
3038             strcat (buf, ", reduced fp model");
3039           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3040             strcat (buf, ", no function descriptors, constant gp");
3041           else if ((e_flags & EF_IA_64_CONS_GP))
3042             strcat (buf, ", constant gp");
3043           if ((e_flags & EF_IA_64_ABSOLUTE))
3044             strcat (buf, ", absolute");
3045           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3046             {
3047               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3048                 strcat (buf, ", vms_linkages");
3049               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3050                 {
3051                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3052                   break;
3053                 case EF_IA_64_VMS_COMCOD_WARNING:
3054                   strcat (buf, ", warning");
3055                   break;
3056                 case EF_IA_64_VMS_COMCOD_ERROR:
3057                   strcat (buf, ", error");
3058                   break;
3059                 case EF_IA_64_VMS_COMCOD_ABORT:
3060                   strcat (buf, ", abort");
3061                   break;
3062                 default:
3063                   abort ();
3064                 }
3065             }
3066           break;
3067
3068         case EM_VAX:
3069           if ((e_flags & EF_VAX_NONPIC))
3070             strcat (buf, ", non-PIC");
3071           if ((e_flags & EF_VAX_DFLOAT))
3072             strcat (buf, ", D-Float");
3073           if ((e_flags & EF_VAX_GFLOAT))
3074             strcat (buf, ", G-Float");
3075           break;
3076
3077         case EM_RL78:
3078           if (e_flags & E_FLAG_RL78_G10)
3079             strcat (buf, ", G10");
3080           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3081             strcat (buf, ", 64-bit doubles");
3082           break;
3083
3084         case EM_RX:
3085           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3086             strcat (buf, ", 64-bit doubles");
3087           if (e_flags & E_FLAG_RX_DSP)
3088             strcat (buf, ", dsp");
3089           if (e_flags & E_FLAG_RX_PID)
3090             strcat (buf, ", pid");
3091           if (e_flags & E_FLAG_RX_ABI)
3092             strcat (buf, ", RX ABI");
3093           break;
3094
3095         case EM_S390:
3096           if (e_flags & EF_S390_HIGH_GPRS)
3097             strcat (buf, ", highgprs");
3098           break;
3099
3100         case EM_TI_C6000:
3101           if ((e_flags & EF_C6000_REL))
3102             strcat (buf, ", relocatable module");
3103           break;
3104
3105         case EM_MSP430:
3106           strcat (buf, _(": architecture variant: "));
3107           switch (e_flags & EF_MSP430_MACH)
3108             {
3109             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3110             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3111             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3112             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3113             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3114             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3115             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3116             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3117             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3118             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3119             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3120             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3121             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3122             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3123             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3124             default:
3125               strcat (buf, _(": unknown")); break;
3126             }
3127
3128           if (e_flags & ~ EF_MSP430_MACH)
3129             strcat (buf, _(": unknown extra flag bits also present"));
3130         }
3131     }
3132
3133   return buf;
3134 }
3135
3136 static const char *
3137 get_osabi_name (unsigned int osabi)
3138 {
3139   static char buff[32];
3140
3141   switch (osabi)
3142     {
3143     case ELFOSABI_NONE:         return "UNIX - System V";
3144     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3145     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3146     case ELFOSABI_GNU:          return "UNIX - GNU";
3147     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3148     case ELFOSABI_AIX:          return "UNIX - AIX";
3149     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3150     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3151     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3152     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3153     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3154     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3155     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3156     case ELFOSABI_AROS:         return "AROS";
3157     case ELFOSABI_FENIXOS:      return "FenixOS";
3158     default:
3159       if (osabi >= 64)
3160         switch (elf_header.e_machine)
3161           {
3162           case EM_ARM:
3163             switch (osabi)
3164               {
3165               case ELFOSABI_ARM:        return "ARM";
3166               default:
3167                 break;
3168               }
3169             break;
3170
3171           case EM_MSP430:
3172           case EM_MSP430_OLD:
3173             switch (osabi)
3174               {
3175               case ELFOSABI_STANDALONE: return _("Standalone App");
3176               default:
3177                 break;
3178               }
3179             break;
3180
3181           case EM_TI_C6000:
3182             switch (osabi)
3183               {
3184               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3185               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3186               default:
3187                 break;
3188               }
3189             break;
3190
3191           default:
3192             break;
3193           }
3194       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3195       return buff;
3196     }
3197 }
3198
3199 static const char *
3200 get_aarch64_segment_type (unsigned long type)
3201 {
3202   switch (type)
3203     {
3204     case PT_AARCH64_ARCHEXT:
3205       return "AARCH64_ARCHEXT";
3206     default:
3207       break;
3208     }
3209
3210   return NULL;
3211 }
3212
3213 static const char *
3214 get_arm_segment_type (unsigned long type)
3215 {
3216   switch (type)
3217     {
3218     case PT_ARM_EXIDX:
3219       return "EXIDX";
3220     default:
3221       break;
3222     }
3223
3224   return NULL;
3225 }
3226
3227 static const char *
3228 get_mips_segment_type (unsigned long type)
3229 {
3230   switch (type)
3231     {
3232     case PT_MIPS_REGINFO:
3233       return "REGINFO";
3234     case PT_MIPS_RTPROC:
3235       return "RTPROC";
3236     case PT_MIPS_OPTIONS:
3237       return "OPTIONS";
3238     case PT_MIPS_ABIFLAGS:
3239       return "ABIFLAGS";
3240     default:
3241       break;
3242     }
3243
3244   return NULL;
3245 }
3246
3247 static const char *
3248 get_parisc_segment_type (unsigned long type)
3249 {
3250   switch (type)
3251     {
3252     case PT_HP_TLS:             return "HP_TLS";
3253     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3254     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3255     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3256     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3257     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3258     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3259     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3260     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3261     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3262     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3263     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3264     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3265     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3266     case PT_HP_STACK:           return "HP_STACK";
3267     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3268     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3269     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3270     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3271     default:
3272       break;
3273     }
3274
3275   return NULL;
3276 }
3277
3278 static const char *
3279 get_ia64_segment_type (unsigned long type)
3280 {
3281   switch (type)
3282     {
3283     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3284     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3285     case PT_HP_TLS:             return "HP_TLS";
3286     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3287     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3288     case PT_IA_64_HP_STACK:     return "HP_STACK";
3289     default:
3290       break;
3291     }
3292
3293   return NULL;
3294 }
3295
3296 static const char *
3297 get_tic6x_segment_type (unsigned long type)
3298 {
3299   switch (type)
3300     {
3301     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3302     default:
3303       break;
3304     }
3305
3306   return NULL;
3307 }
3308
3309 static const char *
3310 get_segment_type (unsigned long p_type)
3311 {
3312   static char buff[32];
3313
3314   switch (p_type)
3315     {
3316     case PT_NULL:       return "NULL";
3317     case PT_LOAD:       return "LOAD";
3318     case PT_DYNAMIC:    return "DYNAMIC";
3319     case PT_INTERP:     return "INTERP";
3320     case PT_NOTE:       return "NOTE";
3321     case PT_SHLIB:      return "SHLIB";
3322     case PT_PHDR:       return "PHDR";
3323     case PT_TLS:        return "TLS";
3324
3325     case PT_GNU_EH_FRAME:
3326                         return "GNU_EH_FRAME";
3327     case PT_GNU_STACK:  return "GNU_STACK";
3328     case PT_GNU_RELRO:  return "GNU_RELRO";
3329
3330     default:
3331       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3332         {
3333           const char * result;
3334
3335           switch (elf_header.e_machine)
3336             {
3337             case EM_AARCH64:
3338               result = get_aarch64_segment_type (p_type);
3339               break;
3340             case EM_ARM:
3341               result = get_arm_segment_type (p_type);
3342               break;
3343             case EM_MIPS:
3344             case EM_MIPS_RS3_LE:
3345               result = get_mips_segment_type (p_type);
3346               break;
3347             case EM_PARISC:
3348               result = get_parisc_segment_type (p_type);
3349               break;
3350             case EM_IA_64:
3351               result = get_ia64_segment_type (p_type);
3352               break;
3353             case EM_TI_C6000:
3354               result = get_tic6x_segment_type (p_type);
3355               break;
3356             default:
3357               result = NULL;
3358               break;
3359             }
3360
3361           if (result != NULL)
3362             return result;
3363
3364           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3365         }
3366       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3367         {
3368           const char * result;
3369
3370           switch (elf_header.e_machine)
3371             {
3372             case EM_PARISC:
3373               result = get_parisc_segment_type (p_type);
3374               break;
3375             case EM_IA_64:
3376               result = get_ia64_segment_type (p_type);
3377               break;
3378             default:
3379               result = NULL;
3380               break;
3381             }
3382
3383           if (result != NULL)
3384             return result;
3385
3386           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3387         }
3388       else
3389         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3390
3391       return buff;
3392     }
3393 }
3394
3395 static const char *
3396 get_mips_section_type_name (unsigned int sh_type)
3397 {
3398   switch (sh_type)
3399     {
3400     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3401     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3402     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3403     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3404     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3405     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3406     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3407     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3408     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3409     case SHT_MIPS_RELD:          return "MIPS_RELD";
3410     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3411     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3412     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3413     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3414     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3415     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3416     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3417     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3418     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3419     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3420     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3421     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3422     case SHT_MIPS_LINE:          return "MIPS_LINE";
3423     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3424     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3425     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3426     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3427     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3428     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3429     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3430     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3431     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3432     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3433     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3434     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3435     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3436     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3437     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3438     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3439     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3440     default:
3441       break;
3442     }
3443   return NULL;
3444 }
3445
3446 static const char *
3447 get_parisc_section_type_name (unsigned int sh_type)
3448 {
3449   switch (sh_type)
3450     {
3451     case SHT_PARISC_EXT:        return "PARISC_EXT";
3452     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3453     case SHT_PARISC_DOC:        return "PARISC_DOC";
3454     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3455     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3456     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3457     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3458     default:
3459       break;
3460     }
3461   return NULL;
3462 }
3463
3464 static const char *
3465 get_ia64_section_type_name (unsigned int sh_type)
3466 {
3467   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3468   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3469     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3470
3471   switch (sh_type)
3472     {
3473     case SHT_IA_64_EXT:                return "IA_64_EXT";
3474     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3475     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3476     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3477     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3478     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3479     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3480     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3481     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3482     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3483     default:
3484       break;
3485     }
3486   return NULL;
3487 }
3488
3489 static const char *
3490 get_x86_64_section_type_name (unsigned int sh_type)
3491 {
3492   switch (sh_type)
3493     {
3494     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3495     default:
3496       break;
3497     }
3498   return NULL;
3499 }
3500
3501 static const char *
3502 get_aarch64_section_type_name (unsigned int sh_type)
3503 {
3504   switch (sh_type)
3505     {
3506     case SHT_AARCH64_ATTRIBUTES:
3507       return "AARCH64_ATTRIBUTES";
3508     default:
3509       break;
3510     }
3511   return NULL;
3512 }
3513
3514 static const char *
3515 get_arm_section_type_name (unsigned int sh_type)
3516 {
3517   switch (sh_type)
3518     {
3519     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3520     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3521     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3522     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3523     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3524     default:
3525       break;
3526     }
3527   return NULL;
3528 }
3529
3530 static const char *
3531 get_tic6x_section_type_name (unsigned int sh_type)
3532 {
3533   switch (sh_type)
3534     {
3535     case SHT_C6000_UNWIND:
3536       return "C6000_UNWIND";
3537     case SHT_C6000_PREEMPTMAP:
3538       return "C6000_PREEMPTMAP";
3539     case SHT_C6000_ATTRIBUTES:
3540       return "C6000_ATTRIBUTES";
3541     case SHT_TI_ICODE:
3542       return "TI_ICODE";
3543     case SHT_TI_XREF:
3544       return "TI_XREF";
3545     case SHT_TI_HANDLER:
3546       return "TI_HANDLER";
3547     case SHT_TI_INITINFO:
3548       return "TI_INITINFO";
3549     case SHT_TI_PHATTRS:
3550       return "TI_PHATTRS";
3551     default:
3552       break;
3553     }
3554   return NULL;
3555 }
3556
3557 static const char *
3558 get_msp430x_section_type_name (unsigned int sh_type)
3559 {
3560   switch (sh_type)
3561     {
3562     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3563     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3564     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3565     default: return NULL;
3566     }
3567 }
3568
3569 static const char *
3570 get_section_type_name (unsigned int sh_type)
3571 {
3572   static char buff[32];
3573
3574   switch (sh_type)
3575     {
3576     case SHT_NULL:              return "NULL";
3577     case SHT_PROGBITS:          return "PROGBITS";
3578     case SHT_SYMTAB:            return "SYMTAB";
3579     case SHT_STRTAB:            return "STRTAB";
3580     case SHT_RELA:              return "RELA";
3581     case SHT_HASH:              return "HASH";
3582     case SHT_DYNAMIC:           return "DYNAMIC";
3583     case SHT_NOTE:              return "NOTE";
3584     case SHT_NOBITS:            return "NOBITS";
3585     case SHT_REL:               return "REL";
3586     case SHT_SHLIB:             return "SHLIB";
3587     case SHT_DYNSYM:            return "DYNSYM";
3588     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3589     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3590     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3591     case SHT_GNU_HASH:          return "GNU_HASH";
3592     case SHT_GROUP:             return "GROUP";
3593     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3594     case SHT_GNU_verdef:        return "VERDEF";
3595     case SHT_GNU_verneed:       return "VERNEED";
3596     case SHT_GNU_versym:        return "VERSYM";
3597     case 0x6ffffff0:            return "VERSYM";
3598     case 0x6ffffffc:            return "VERDEF";
3599     case 0x7ffffffd:            return "AUXILIARY";
3600     case 0x7fffffff:            return "FILTER";
3601     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3602
3603     default:
3604       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3605         {
3606           const char * result;
3607
3608           switch (elf_header.e_machine)
3609             {
3610             case EM_MIPS:
3611             case EM_MIPS_RS3_LE:
3612               result = get_mips_section_type_name (sh_type);
3613               break;
3614             case EM_PARISC:
3615               result = get_parisc_section_type_name (sh_type);
3616               break;
3617             case EM_IA_64:
3618               result = get_ia64_section_type_name (sh_type);
3619               break;
3620             case EM_X86_64:
3621             case EM_L1OM:
3622             case EM_K1OM:
3623               result = get_x86_64_section_type_name (sh_type);
3624               break;
3625             case EM_AARCH64:
3626               result = get_aarch64_section_type_name (sh_type);
3627               break;
3628             case EM_ARM:
3629               result = get_arm_section_type_name (sh_type);
3630               break;
3631             case EM_TI_C6000:
3632               result = get_tic6x_section_type_name (sh_type);
3633               break;
3634             case EM_MSP430:
3635               result = get_msp430x_section_type_name (sh_type);
3636               break;
3637             default:
3638               result = NULL;
3639               break;
3640             }
3641
3642           if (result != NULL)
3643             return result;
3644
3645           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3646         }
3647       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3648         {
3649           const char * result;
3650
3651           switch (elf_header.e_machine)
3652             {
3653             case EM_IA_64:
3654               result = get_ia64_section_type_name (sh_type);
3655               break;
3656             default:
3657               result = NULL;
3658               break;
3659             }
3660
3661           if (result != NULL)
3662             return result;
3663
3664           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3665         }
3666       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3667         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3668       else
3669         /* This message is probably going to be displayed in a 15
3670            character wide field, so put the hex value first.  */
3671         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3672
3673       return buff;
3674     }
3675 }
3676
3677 #define OPTION_DEBUG_DUMP       512
3678 #define OPTION_DYN_SYMS         513
3679 #define OPTION_DWARF_DEPTH      514
3680 #define OPTION_DWARF_START      515
3681 #define OPTION_DWARF_CHECK      516
3682
3683 static struct option options[] =
3684 {
3685   {"all",              no_argument, 0, 'a'},
3686   {"file-header",      no_argument, 0, 'h'},
3687   {"program-headers",  no_argument, 0, 'l'},
3688   {"headers",          no_argument, 0, 'e'},
3689   {"histogram",        no_argument, 0, 'I'},
3690   {"segments",         no_argument, 0, 'l'},
3691   {"sections",         no_argument, 0, 'S'},
3692   {"section-headers",  no_argument, 0, 'S'},
3693   {"section-groups",   no_argument, 0, 'g'},
3694   {"section-details",  no_argument, 0, 't'},
3695   {"full-section-name",no_argument, 0, 'N'},
3696   {"symbols",          no_argument, 0, 's'},
3697   {"syms",             no_argument, 0, 's'},
3698   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3699   {"relocs",           no_argument, 0, 'r'},
3700   {"notes",            no_argument, 0, 'n'},
3701   {"dynamic",          no_argument, 0, 'd'},
3702   {"arch-specific",    no_argument, 0, 'A'},
3703   {"version-info",     no_argument, 0, 'V'},
3704   {"use-dynamic",      no_argument, 0, 'D'},
3705   {"unwind",           no_argument, 0, 'u'},
3706   {"archive-index",    no_argument, 0, 'c'},
3707   {"hex-dump",         required_argument, 0, 'x'},
3708   {"relocated-dump",   required_argument, 0, 'R'},
3709   {"string-dump",      required_argument, 0, 'p'},
3710 #ifdef SUPPORT_DISASSEMBLY
3711   {"instruction-dump", required_argument, 0, 'i'},
3712 #endif
3713   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3714
3715   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3716   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3717   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3718
3719   {"version",          no_argument, 0, 'v'},
3720   {"wide",             no_argument, 0, 'W'},
3721   {"help",             no_argument, 0, 'H'},
3722   {0,                  no_argument, 0, 0}
3723 };
3724
3725 static void
3726 usage (FILE * stream)
3727 {
3728   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3729   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3730   fprintf (stream, _(" Options are:\n\
3731   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3732   -h --file-header       Display the ELF file header\n\
3733   -l --program-headers   Display the program headers\n\
3734      --segments          An alias for --program-headers\n\
3735   -S --section-headers   Display the sections' header\n\
3736      --sections          An alias for --section-headers\n\
3737   -g --section-groups    Display the section groups\n\
3738   -t --section-details   Display the section details\n\
3739   -e --headers           Equivalent to: -h -l -S\n\
3740   -s --syms              Display the symbol table\n\
3741      --symbols           An alias for --syms\n\
3742   --dyn-syms             Display the dynamic symbol table\n\
3743   -n --notes             Display the core notes (if present)\n\
3744   -r --relocs            Display the relocations (if present)\n\
3745   -u --unwind            Display the unwind info (if present)\n\
3746   -d --dynamic           Display the dynamic section (if present)\n\
3747   -V --version-info      Display the version sections (if present)\n\
3748   -A --arch-specific     Display architecture specific information (if any)\n\
3749   -c --archive-index     Display the symbol/file index in an archive\n\
3750   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3751   -x --hex-dump=<number|name>\n\
3752                          Dump the contents of section <number|name> as bytes\n\
3753   -p --string-dump=<number|name>\n\
3754                          Dump the contents of section <number|name> as strings\n\
3755   -R --relocated-dump=<number|name>\n\
3756                          Dump the contents of section <number|name> as relocated bytes\n\
3757   -w[lLiaprmfFsoRt] or\n\
3758   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3759                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3760                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3761                =addr,=cu_index]\n\
3762                          Display the contents of DWARF2 debug sections\n"));
3763   fprintf (stream, _("\
3764   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3765   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3766                          or deeper\n"));
3767 #ifdef SUPPORT_DISASSEMBLY
3768   fprintf (stream, _("\
3769   -i --instruction-dump=<number|name>\n\
3770                          Disassemble the contents of section <number|name>\n"));
3771 #endif
3772   fprintf (stream, _("\
3773   -I --histogram         Display histogram of bucket list lengths\n\
3774   -W --wide              Allow output width to exceed 80 characters\n\
3775   @<file>                Read options from <file>\n\
3776   -H --help              Display this information\n\
3777   -v --version           Display the version number of readelf\n"));
3778
3779   if (REPORT_BUGS_TO[0] && stream == stdout)
3780     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3781
3782   exit (stream == stdout ? 0 : 1);
3783 }
3784
3785 /* Record the fact that the user wants the contents of section number
3786    SECTION to be displayed using the method(s) encoded as flags bits
3787    in TYPE.  Note, TYPE can be zero if we are creating the array for
3788    the first time.  */
3789
3790 static void
3791 request_dump_bynumber (unsigned int section, dump_type type)
3792 {
3793   if (section >= num_dump_sects)
3794     {
3795       dump_type * new_dump_sects;
3796
3797       new_dump_sects = (dump_type *) calloc (section + 1,
3798                                              sizeof (* dump_sects));
3799
3800       if (new_dump_sects == NULL)
3801         error (_("Out of memory allocating dump request table.\n"));
3802       else
3803         {
3804           /* Copy current flag settings.  */
3805           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3806
3807           free (dump_sects);
3808
3809           dump_sects = new_dump_sects;
3810           num_dump_sects = section + 1;
3811         }
3812     }
3813
3814   if (dump_sects)
3815     dump_sects[section] |= type;
3816
3817   return;
3818 }
3819
3820 /* Request a dump by section name.  */
3821
3822 static void
3823 request_dump_byname (const char * section, dump_type type)
3824 {
3825   struct dump_list_entry * new_request;
3826
3827   new_request = (struct dump_list_entry *)
3828       malloc (sizeof (struct dump_list_entry));
3829   if (!new_request)
3830     error (_("Out of memory allocating dump request table.\n"));
3831
3832   new_request->name = strdup (section);
3833   if (!new_request->name)
3834     error (_("Out of memory allocating dump request table.\n"));
3835
3836   new_request->type = type;
3837
3838   new_request->next = dump_sects_byname;
3839   dump_sects_byname = new_request;
3840 }
3841
3842 static inline void
3843 request_dump (dump_type type)
3844 {
3845   int section;
3846   char * cp;
3847
3848   do_dump++;
3849   section = strtoul (optarg, & cp, 0);
3850
3851   if (! *cp && section >= 0)
3852     request_dump_bynumber (section, type);
3853   else
3854     request_dump_byname (optarg, type);
3855 }
3856
3857
3858 static void
3859 parse_args (int argc, char ** argv)
3860 {
3861   int c;
3862
3863   if (argc < 2)
3864     usage (stderr);
3865
3866   while ((c = getopt_long
3867           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3868     {
3869       switch (c)
3870         {
3871         case 0:
3872           /* Long options.  */
3873           break;
3874         case 'H':
3875           usage (stdout);
3876           break;
3877
3878         case 'a':
3879           do_syms++;
3880           do_reloc++;
3881           do_unwind++;
3882           do_dynamic++;
3883           do_header++;
3884           do_sections++;
3885           do_section_groups++;
3886           do_segments++;
3887           do_version++;
3888           do_histogram++;
3889           do_arch++;
3890           do_notes++;
3891           break;
3892         case 'g':
3893           do_section_groups++;
3894           break;
3895         case 't':
3896         case 'N':
3897           do_sections++;
3898           do_section_details++;
3899           break;
3900         case 'e':
3901           do_header++;
3902           do_sections++;
3903           do_segments++;
3904           break;
3905         case 'A':
3906           do_arch++;
3907           break;
3908         case 'D':
3909           do_using_dynamic++;
3910           break;
3911         case 'r':
3912           do_reloc++;
3913           break;
3914         case 'u':
3915           do_unwind++;
3916           break;
3917         case 'h':
3918           do_header++;
3919           break;
3920         case 'l':
3921           do_segments++;
3922           break;
3923         case 's':
3924           do_syms++;
3925           break;
3926         case 'S':
3927           do_sections++;
3928           break;
3929         case 'd':
3930           do_dynamic++;
3931           break;
3932         case 'I':
3933           do_histogram++;
3934           break;
3935         case 'n':
3936           do_notes++;
3937           break;
3938         case 'c':
3939           do_archive_index++;
3940           break;
3941         case 'x':
3942           request_dump (HEX_DUMP);
3943           break;
3944         case 'p':
3945           request_dump (STRING_DUMP);
3946           break;
3947         case 'R':
3948           request_dump (RELOC_DUMP);
3949           break;
3950         case 'w':
3951           do_dump++;
3952           if (optarg == 0)
3953             {
3954               do_debugging = 1;
3955               dwarf_select_sections_all ();
3956             }
3957           else
3958             {
3959               do_debugging = 0;
3960               dwarf_select_sections_by_letters (optarg);
3961             }
3962           break;
3963         case OPTION_DEBUG_DUMP:
3964           do_dump++;
3965           if (optarg == 0)
3966             do_debugging = 1;
3967           else
3968             {
3969               do_debugging = 0;
3970               dwarf_select_sections_by_names (optarg);
3971             }
3972           break;
3973         case OPTION_DWARF_DEPTH:
3974           {
3975             char *cp;
3976
3977             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3978           }
3979           break;
3980         case OPTION_DWARF_START:
3981           {
3982             char *cp;
3983
3984             dwarf_start_die = strtoul (optarg, & cp, 0);
3985           }
3986           break;
3987         case OPTION_DWARF_CHECK:
3988           dwarf_check = 1;
3989           break;
3990         case OPTION_DYN_SYMS:
3991           do_dyn_syms++;
3992           break;
3993 #ifdef SUPPORT_DISASSEMBLY
3994         case 'i':
3995           request_dump (DISASS_DUMP);
3996           break;
3997 #endif
3998         case 'v':
3999           print_version (program_name);
4000           break;
4001         case 'V':
4002           do_version++;
4003           break;
4004         case 'W':
4005           do_wide++;
4006           break;
4007         default:
4008           /* xgettext:c-format */
4009           error (_("Invalid option '-%c'\n"), c);
4010           /* Drop through.  */
4011         case '?':
4012           usage (stderr);
4013         }
4014     }
4015
4016   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4017       && !do_segments && !do_header && !do_dump && !do_version
4018       && !do_histogram && !do_debugging && !do_arch && !do_notes
4019       && !do_section_groups && !do_archive_index
4020       && !do_dyn_syms)
4021     usage (stderr);
4022   else if (argc < 3)
4023     {
4024       warn (_("Nothing to do.\n"));
4025       usage (stderr);
4026     }
4027 }
4028
4029 static const char *
4030 get_elf_class (unsigned int elf_class)
4031 {
4032   static char buff[32];
4033
4034   switch (elf_class)
4035     {
4036     case ELFCLASSNONE: return _("none");
4037     case ELFCLASS32:   return "ELF32";
4038     case ELFCLASS64:   return "ELF64";
4039     default:
4040       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4041       return buff;
4042     }
4043 }
4044
4045 static const char *
4046 get_data_encoding (unsigned int encoding)
4047 {
4048   static char buff[32];
4049
4050   switch (encoding)
4051     {
4052     case ELFDATANONE: return _("none");
4053     case ELFDATA2LSB: return _("2's complement, little endian");
4054     case ELFDATA2MSB: return _("2's complement, big endian");
4055     default:
4056       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4057       return buff;
4058     }
4059 }
4060
4061 /* Decode the data held in 'elf_header'.  */
4062
4063 static int
4064 process_file_header (void)
4065 {
4066   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4067       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4068       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4069       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4070     {
4071       error
4072         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4073       return 0;
4074     }
4075
4076   init_dwarf_regnames (elf_header.e_machine);
4077
4078   if (do_header)
4079     {
4080       int i;
4081
4082       printf (_("ELF Header:\n"));
4083       printf (_("  Magic:   "));
4084       for (i = 0; i < EI_NIDENT; i++)
4085         printf ("%2.2x ", elf_header.e_ident[i]);
4086       printf ("\n");
4087       printf (_("  Class:                             %s\n"),
4088               get_elf_class (elf_header.e_ident[EI_CLASS]));
4089       printf (_("  Data:                              %s\n"),
4090               get_data_encoding (elf_header.e_ident[EI_DATA]));
4091       printf (_("  Version:                           %d %s\n"),
4092               elf_header.e_ident[EI_VERSION],
4093               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4094                ? "(current)"
4095                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4096                   ? _("<unknown: %lx>")
4097                   : "")));
4098       printf (_("  OS/ABI:                            %s\n"),
4099               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4100       printf (_("  ABI Version:                       %d\n"),
4101               elf_header.e_ident[EI_ABIVERSION]);
4102       printf (_("  Type:                              %s\n"),
4103               get_file_type (elf_header.e_type));
4104       printf (_("  Machine:                           %s\n"),
4105               get_machine_name (elf_header.e_machine));
4106       printf (_("  Version:                           0x%lx\n"),
4107               (unsigned long) elf_header.e_version);
4108
4109       printf (_("  Entry point address:               "));
4110       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4111       printf (_("\n  Start of program headers:          "));
4112       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4113       printf (_(" (bytes into file)\n  Start of section headers:          "));
4114       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4115       printf (_(" (bytes into file)\n"));
4116
4117       printf (_("  Flags:                             0x%lx%s\n"),
4118               (unsigned long) elf_header.e_flags,
4119               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4120       printf (_("  Size of this header:               %ld (bytes)\n"),
4121               (long) elf_header.e_ehsize);
4122       printf (_("  Size of program headers:           %ld (bytes)\n"),
4123               (long) elf_header.e_phentsize);
4124       printf (_("  Number of program headers:         %ld"),
4125               (long) elf_header.e_phnum);
4126       if (section_headers != NULL
4127           && elf_header.e_phnum == PN_XNUM
4128           && section_headers[0].sh_info != 0)
4129         printf (" (%ld)", (long) section_headers[0].sh_info);
4130       putc ('\n', stdout);
4131       printf (_("  Size of section headers:           %ld (bytes)\n"),
4132               (long) elf_header.e_shentsize);
4133       printf (_("  Number of section headers:         %ld"),
4134               (long) elf_header.e_shnum);
4135       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4136         printf (" (%ld)", (long) section_headers[0].sh_size);
4137       putc ('\n', stdout);
4138       printf (_("  Section header string table index: %ld"),
4139               (long) elf_header.e_shstrndx);
4140       if (section_headers != NULL
4141           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4142         printf (" (%u)", section_headers[0].sh_link);
4143       else if (elf_header.e_shstrndx != SHN_UNDEF
4144                && elf_header.e_shstrndx >= elf_header.e_shnum)
4145         printf (_(" <corrupt: out of range>"));
4146       putc ('\n', stdout);
4147     }
4148
4149   if (section_headers != NULL)
4150     {
4151       if (elf_header.e_phnum == PN_XNUM
4152           && section_headers[0].sh_info != 0)
4153         elf_header.e_phnum = section_headers[0].sh_info;
4154       if (elf_header.e_shnum == SHN_UNDEF)
4155         elf_header.e_shnum = section_headers[0].sh_size;
4156       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4157         elf_header.e_shstrndx = section_headers[0].sh_link;
4158       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4159         elf_header.e_shstrndx = SHN_UNDEF;
4160       free (section_headers);
4161       section_headers = NULL;
4162     }
4163
4164   return 1;
4165 }
4166
4167 static bfd_boolean
4168 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4169 {
4170   Elf32_External_Phdr * phdrs;
4171   Elf32_External_Phdr * external;
4172   Elf_Internal_Phdr *   internal;
4173   unsigned int i;
4174   unsigned int size = elf_header.e_phentsize;
4175   unsigned int num  = elf_header.e_phnum;
4176
4177   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4178   if (size == 0 || num == 0)
4179     return FALSE;
4180   if (size < sizeof * phdrs)
4181     {
4182       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4183       return FALSE;
4184     }
4185   if (size > sizeof * phdrs)
4186     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4187
4188   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4189                                             size, num, _("program headers"));
4190   if (phdrs == NULL)
4191     return FALSE;
4192
4193   for (i = 0, internal = pheaders, external = phdrs;
4194        i < elf_header.e_phnum;
4195        i++, internal++, external++)
4196     {
4197       internal->p_type   = BYTE_GET (external->p_type);
4198       internal->p_offset = BYTE_GET (external->p_offset);
4199       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4200       internal->p_paddr  = BYTE_GET (external->p_paddr);
4201       internal->p_filesz = BYTE_GET (external->p_filesz);
4202       internal->p_memsz  = BYTE_GET (external->p_memsz);
4203       internal->p_flags  = BYTE_GET (external->p_flags);
4204       internal->p_align  = BYTE_GET (external->p_align);
4205     }
4206
4207   free (phdrs);
4208   return TRUE;
4209 }
4210
4211 static bfd_boolean
4212 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4213 {
4214   Elf64_External_Phdr * phdrs;
4215   Elf64_External_Phdr * external;
4216   Elf_Internal_Phdr *   internal;
4217   unsigned int i;
4218   unsigned int size = elf_header.e_phentsize;
4219   unsigned int num  = elf_header.e_phnum;
4220
4221   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4222   if (size == 0 || num == 0)
4223     return FALSE;
4224   if (size < sizeof * phdrs)
4225     {
4226       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4227       return FALSE;
4228     }
4229   if (size > sizeof * phdrs)
4230     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4231
4232   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4233                                             size, num, _("program headers"));
4234   if (!phdrs)
4235     return FALSE;
4236
4237   for (i = 0, internal = pheaders, external = phdrs;
4238        i < elf_header.e_phnum;
4239        i++, internal++, external++)
4240     {
4241       internal->p_type   = BYTE_GET (external->p_type);
4242       internal->p_flags  = BYTE_GET (external->p_flags);
4243       internal->p_offset = BYTE_GET (external->p_offset);
4244       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4245       internal->p_paddr  = BYTE_GET (external->p_paddr);
4246       internal->p_filesz = BYTE_GET (external->p_filesz);
4247       internal->p_memsz  = BYTE_GET (external->p_memsz);
4248       internal->p_align  = BYTE_GET (external->p_align);
4249     }
4250
4251   free (phdrs);
4252   return TRUE;
4253 }
4254
4255 /* Returns 1 if the program headers were read into `program_headers'.  */
4256
4257 static int
4258 get_program_headers (FILE * file)
4259 {
4260   Elf_Internal_Phdr * phdrs;
4261
4262   /* Check cache of prior read.  */
4263   if (program_headers != NULL)
4264     return 1;
4265
4266   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4267                                          sizeof (Elf_Internal_Phdr));
4268
4269   if (phdrs == NULL)
4270     {
4271       error (_("Out of memory\n"));
4272       return 0;
4273     }
4274
4275   if (is_32bit_elf
4276       ? get_32bit_program_headers (file, phdrs)
4277       : get_64bit_program_headers (file, phdrs))
4278     {
4279       program_headers = phdrs;
4280       return 1;
4281     }
4282
4283   free (phdrs);
4284   return 0;
4285 }
4286
4287 /* Returns 1 if the program headers were loaded.  */
4288
4289 static int
4290 process_program_headers (FILE * file)
4291 {
4292   Elf_Internal_Phdr * segment;
4293   unsigned int i;
4294
4295   if (elf_header.e_phnum == 0)
4296     {
4297       /* PR binutils/12467.  */
4298       if (elf_header.e_phoff != 0)
4299         warn (_("possibly corrupt ELF header - it has a non-zero program"
4300                 " header offset, but no program headers"));
4301       else if (do_segments)
4302         printf (_("\nThere are no program headers in this file.\n"));
4303       return 0;
4304     }
4305
4306   if (do_segments && !do_header)
4307     {
4308       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4309       printf (_("Entry point "));
4310       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4311       printf (_("\nThere are %d program headers, starting at offset "),
4312               elf_header.e_phnum);
4313       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4314       printf ("\n");
4315     }
4316
4317   if (! get_program_headers (file))
4318       return 0;
4319
4320   if (do_segments)
4321     {
4322       if (elf_header.e_phnum > 1)
4323         printf (_("\nProgram Headers:\n"));
4324       else
4325         printf (_("\nProgram Headers:\n"));
4326
4327       if (is_32bit_elf)
4328         printf
4329           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4330       else if (do_wide)
4331         printf
4332           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4333       else
4334         {
4335           printf
4336             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4337           printf
4338             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4339         }
4340     }
4341
4342   dynamic_addr = 0;
4343   dynamic_size = 0;
4344
4345   for (i = 0, segment = program_headers;
4346        i < elf_header.e_phnum;
4347        i++, segment++)
4348     {
4349       if (do_segments)
4350         {
4351           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4352
4353           if (is_32bit_elf)
4354             {
4355               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4356               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4357               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4358               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4359               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4360               printf ("%c%c%c ",
4361                       (segment->p_flags & PF_R ? 'R' : ' '),
4362                       (segment->p_flags & PF_W ? 'W' : ' '),
4363                       (segment->p_flags & PF_X ? 'E' : ' '));
4364               printf ("%#lx", (unsigned long) segment->p_align);
4365             }
4366           else if (do_wide)
4367             {
4368               if ((unsigned long) segment->p_offset == segment->p_offset)
4369                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4370               else
4371                 {
4372                   print_vma (segment->p_offset, FULL_HEX);
4373                   putchar (' ');
4374                 }
4375
4376               print_vma (segment->p_vaddr, FULL_HEX);
4377               putchar (' ');
4378               print_vma (segment->p_paddr, FULL_HEX);
4379               putchar (' ');
4380
4381               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4382                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4383               else
4384                 {
4385                   print_vma (segment->p_filesz, FULL_HEX);
4386                   putchar (' ');
4387                 }
4388
4389               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4390                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4391               else
4392                 {
4393                   print_vma (segment->p_memsz, FULL_HEX);
4394                 }
4395
4396               printf (" %c%c%c ",
4397                       (segment->p_flags & PF_R ? 'R' : ' '),
4398                       (segment->p_flags & PF_W ? 'W' : ' '),
4399                       (segment->p_flags & PF_X ? 'E' : ' '));
4400
4401               if ((unsigned long) segment->p_align == segment->p_align)
4402                 printf ("%#lx", (unsigned long) segment->p_align);
4403               else
4404                 {
4405                   print_vma (segment->p_align, PREFIX_HEX);
4406                 }
4407             }
4408           else
4409             {
4410               print_vma (segment->p_offset, FULL_HEX);
4411               putchar (' ');
4412               print_vma (segment->p_vaddr, FULL_HEX);
4413               putchar (' ');
4414               print_vma (segment->p_paddr, FULL_HEX);
4415               printf ("\n                 ");
4416               print_vma (segment->p_filesz, FULL_HEX);
4417               putchar (' ');
4418               print_vma (segment->p_memsz, FULL_HEX);
4419               printf ("  %c%c%c    ",
4420                       (segment->p_flags & PF_R ? 'R' : ' '),
4421                       (segment->p_flags & PF_W ? 'W' : ' '),
4422                       (segment->p_flags & PF_X ? 'E' : ' '));
4423               print_vma (segment->p_align, HEX);
4424             }
4425         }
4426
4427       if (do_segments)
4428         putc ('\n', stdout);
4429
4430       switch (segment->p_type)
4431         {
4432         case PT_DYNAMIC:
4433           if (dynamic_addr)
4434             error (_("more than one dynamic segment\n"));
4435
4436           /* By default, assume that the .dynamic section is the first
4437              section in the DYNAMIC segment.  */
4438           dynamic_addr = segment->p_offset;
4439           dynamic_size = segment->p_filesz;
4440           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4441           if (dynamic_addr + dynamic_size >= current_file_size)
4442             {
4443               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4444               dynamic_addr = dynamic_size = 0;
4445             }
4446
4447           /* Try to locate the .dynamic section. If there is
4448              a section header table, we can easily locate it.  */
4449           if (section_headers != NULL)
4450             {
4451               Elf_Internal_Shdr * sec;
4452
4453               sec = find_section (".dynamic");
4454               if (sec == NULL || sec->sh_size == 0)
4455                 {
4456                   /* A corresponding .dynamic section is expected, but on
4457                      IA-64/OpenVMS it is OK for it to be missing.  */
4458                   if (!is_ia64_vms ())
4459                     error (_("no .dynamic section in the dynamic segment\n"));
4460                   break;
4461                 }
4462
4463               if (sec->sh_type == SHT_NOBITS)
4464                 {
4465                   dynamic_size = 0;
4466                   break;
4467                 }
4468
4469               dynamic_addr = sec->sh_offset;
4470               dynamic_size = sec->sh_size;
4471
4472               if (dynamic_addr < segment->p_offset
4473                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4474                 warn (_("the .dynamic section is not contained"
4475                         " within the dynamic segment\n"));
4476               else if (dynamic_addr > segment->p_offset)
4477                 warn (_("the .dynamic section is not the first section"
4478                         " in the dynamic segment.\n"));
4479             }
4480           break;
4481
4482         case PT_INTERP:
4483           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4484                      SEEK_SET))
4485             error (_("Unable to find program interpreter name\n"));
4486           else
4487             {
4488               char fmt [32];
4489               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4490
4491               if (ret >= (int) sizeof (fmt) || ret < 0)
4492                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4493
4494               program_interpreter[0] = 0;
4495               if (fscanf (file, fmt, program_interpreter) <= 0)
4496                 error (_("Unable to read program interpreter name\n"));
4497
4498               if (do_segments)
4499                 printf (_("      [Requesting program interpreter: %s]\n"),
4500                     program_interpreter);
4501             }
4502           break;
4503         }
4504     }
4505
4506   if (do_segments && section_headers != NULL && string_table != NULL)
4507     {
4508       printf (_("\n Section to Segment mapping:\n"));
4509       printf (_("  Segment Sections...\n"));
4510
4511       for (i = 0; i < elf_header.e_phnum; i++)
4512         {
4513           unsigned int j;
4514           Elf_Internal_Shdr * section;
4515
4516           segment = program_headers + i;
4517           section = section_headers + 1;
4518
4519           printf ("   %2.2d     ", i);
4520
4521           for (j = 1; j < elf_header.e_shnum; j++, section++)
4522             {
4523               if (!ELF_TBSS_SPECIAL (section, segment)
4524                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4525                 printf ("%s ", printable_section_name (section));
4526             }
4527
4528           putc ('\n',stdout);
4529         }
4530     }
4531
4532   return 1;
4533 }
4534
4535
4536 /* Find the file offset corresponding to VMA by using the program headers.  */
4537
4538 static long
4539 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4540 {
4541   Elf_Internal_Phdr * seg;
4542
4543   if (! get_program_headers (file))
4544     {
4545       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4546       return (long) vma;
4547     }
4548
4549   for (seg = program_headers;
4550        seg < program_headers + elf_header.e_phnum;
4551        ++seg)
4552     {
4553       if (seg->p_type != PT_LOAD)
4554         continue;
4555
4556       if (vma >= (seg->p_vaddr & -seg->p_align)
4557           && vma + size <= seg->p_vaddr + seg->p_filesz)
4558         return vma - seg->p_vaddr + seg->p_offset;
4559     }
4560
4561   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4562         (unsigned long) vma);
4563   return (long) vma;
4564 }
4565
4566
4567 /* Allocate memory and load the sections headers into the global pointer
4568    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4569    generate any error messages if the load fails.  */
4570
4571 static bfd_boolean
4572 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4573 {
4574   Elf32_External_Shdr * shdrs;
4575   Elf_Internal_Shdr *   internal;
4576   unsigned int i;
4577   unsigned int size = elf_header.e_shentsize;
4578   unsigned int num = probe ? 1 : elf_header.e_shnum;
4579
4580   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4581   if (size == 0 || num == 0)
4582     return FALSE;
4583   if (size < sizeof * shdrs)
4584     {
4585       if (! probe)
4586         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4587       return FALSE;
4588     }
4589   if (!probe && size > sizeof * shdrs)
4590     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4591
4592   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4593                                             size, num,
4594                                             probe ? NULL : _("section headers"));
4595   if (shdrs == NULL)
4596     return FALSE;
4597
4598   if (section_headers != NULL)
4599     free (section_headers);
4600   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4601                                                    sizeof (Elf_Internal_Shdr));
4602   if (section_headers == NULL)
4603     {
4604       if (!probe)
4605         error (_("Out of memory\n"));
4606       return FALSE;
4607     }
4608
4609   for (i = 0, internal = section_headers;
4610        i < num;
4611        i++, internal++)
4612     {
4613       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4614       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4615       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4616       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4617       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4618       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4619       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4620       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4621       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4622       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4623     }
4624
4625   free (shdrs);
4626   return TRUE;
4627 }
4628
4629 static bfd_boolean
4630 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4631 {
4632   Elf64_External_Shdr * shdrs;
4633   Elf_Internal_Shdr *   internal;
4634   unsigned int i;
4635   unsigned int size = elf_header.e_shentsize;
4636   unsigned int num = probe ? 1 : elf_header.e_shnum;
4637
4638   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4639   if (size == 0 || num == 0)
4640     return FALSE;
4641   if (size < sizeof * shdrs)
4642     {
4643       if (! probe)
4644         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4645       return FALSE;
4646     }
4647   if (! probe && size > sizeof * shdrs)
4648     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4649
4650   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4651                                             size, num,
4652                                             probe ? NULL : _("section headers"));
4653   if (shdrs == NULL)
4654     return FALSE;
4655
4656   if (section_headers != NULL)
4657     free (section_headers);
4658   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4659                                                    sizeof (Elf_Internal_Shdr));
4660   if (section_headers == NULL)
4661     {
4662       if (! probe)
4663         error (_("Out of memory\n"));
4664       return FALSE;
4665     }
4666
4667   for (i = 0, internal = section_headers;
4668        i < num;
4669        i++, internal++)
4670     {
4671       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4672       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4673       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4674       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4675       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4676       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4677       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4678       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4679       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4680       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4681     }
4682
4683   free (shdrs);
4684   return TRUE;
4685 }
4686
4687 static Elf_Internal_Sym *
4688 get_32bit_elf_symbols (FILE * file,
4689                        Elf_Internal_Shdr * section,
4690                        unsigned long * num_syms_return)
4691 {
4692   unsigned long number = 0;
4693   Elf32_External_Sym * esyms = NULL;
4694   Elf_External_Sym_Shndx * shndx = NULL;
4695   Elf_Internal_Sym * isyms = NULL;
4696   Elf_Internal_Sym * psym;
4697   unsigned int j;
4698
4699   /* Run some sanity checks first.  */
4700   if (section->sh_entsize == 0)
4701     {
4702       error (_("sh_entsize is zero\n"));
4703       goto exit_point;
4704     }
4705
4706   if (section->sh_size > current_file_size)
4707     {
4708       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4709              printable_section_name (section), (unsigned long) section->sh_size);
4710       goto exit_point;
4711     }
4712
4713   number = section->sh_size / section->sh_entsize;
4714
4715   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4716     {
4717       error (_("Invalid sh_entsize\n"));
4718       goto exit_point;
4719     }
4720
4721   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4722                                            section->sh_size, _("symbols"));
4723   if (esyms == NULL)
4724     goto exit_point;
4725
4726   shndx = NULL;
4727   if (symtab_shndx_hdr != NULL
4728       && (symtab_shndx_hdr->sh_link
4729           == (unsigned long) (section - section_headers)))
4730     {
4731       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4732                                                    symtab_shndx_hdr->sh_offset,
4733                                                    1, symtab_shndx_hdr->sh_size,
4734                                                    _("symbol table section indicies"));
4735       if (shndx == NULL)
4736         goto exit_point;
4737     }
4738
4739   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4740
4741   if (isyms == NULL)
4742     {
4743       error (_("Out of memory\n"));
4744       goto exit_point;
4745     }
4746
4747   for (j = 0, psym = isyms; j < number; j++, psym++)
4748     {
4749       psym->st_name  = BYTE_GET (esyms[j].st_name);
4750       psym->st_value = BYTE_GET (esyms[j].st_value);
4751       psym->st_size  = BYTE_GET (esyms[j].st_size);
4752       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4753       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4754         psym->st_shndx
4755           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4756       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4757         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4758       psym->st_info  = BYTE_GET (esyms[j].st_info);
4759       psym->st_other = BYTE_GET (esyms[j].st_other);
4760     }
4761
4762  exit_point:
4763   if (shndx != NULL)
4764     free (shndx);
4765   if (esyms != NULL)
4766     free (esyms);
4767
4768   if (num_syms_return != NULL)
4769     * num_syms_return = isyms == NULL ? 0 : number;
4770
4771   return isyms;
4772 }
4773
4774 static Elf_Internal_Sym *
4775 get_64bit_elf_symbols (FILE * file,
4776                        Elf_Internal_Shdr * section,
4777                        unsigned long * num_syms_return)
4778 {
4779   unsigned long number = 0;
4780   Elf64_External_Sym * esyms = NULL;
4781   Elf_External_Sym_Shndx * shndx = NULL;
4782   Elf_Internal_Sym * isyms = NULL;
4783   Elf_Internal_Sym * psym;
4784   unsigned int j;
4785
4786   /* Run some sanity checks first.  */
4787   if (section->sh_entsize == 0)
4788     {
4789       error (_("sh_entsize is zero\n"));
4790       goto exit_point;
4791     }
4792
4793   if (section->sh_size > current_file_size)
4794     {
4795       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4796              printable_section_name (section), (unsigned long) section->sh_size);
4797       goto exit_point;
4798     }
4799
4800   number = section->sh_size / section->sh_entsize;
4801
4802   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4803     {
4804       error (_("Invalid sh_entsize\n"));
4805       goto exit_point;
4806     }
4807
4808   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4809                                            section->sh_size, _("symbols"));
4810   if (!esyms)
4811     goto exit_point;
4812
4813   if (symtab_shndx_hdr != NULL
4814       && (symtab_shndx_hdr->sh_link
4815           == (unsigned long) (section - section_headers)))
4816     {
4817       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4818                                                    symtab_shndx_hdr->sh_offset,
4819                                                    1, symtab_shndx_hdr->sh_size,
4820                                                    _("symbol table section indicies"));
4821       if (shndx == NULL)
4822         goto exit_point;
4823     }
4824
4825   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4826
4827   if (isyms == NULL)
4828     {
4829       error (_("Out of memory\n"));
4830       goto exit_point;
4831     }
4832
4833   for (j = 0, psym = isyms; j < number; j++, psym++)
4834     {
4835       psym->st_name  = BYTE_GET (esyms[j].st_name);
4836       psym->st_info  = BYTE_GET (esyms[j].st_info);
4837       psym->st_other = BYTE_GET (esyms[j].st_other);
4838       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4839
4840       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4841         psym->st_shndx
4842           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4843       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4844         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4845
4846       psym->st_value = BYTE_GET (esyms[j].st_value);
4847       psym->st_size  = BYTE_GET (esyms[j].st_size);
4848     }
4849
4850  exit_point:
4851   if (shndx != NULL)
4852     free (shndx);
4853   if (esyms != NULL)
4854     free (esyms);
4855
4856   if (num_syms_return != NULL)
4857     * num_syms_return = isyms == NULL ? 0 : number;
4858
4859   return isyms;
4860 }
4861
4862 static const char *
4863 get_elf_section_flags (bfd_vma sh_flags)
4864 {
4865   static char buff[1024];
4866   char * p = buff;
4867   int field_size = is_32bit_elf ? 8 : 16;
4868   int sindex;
4869   int size = sizeof (buff) - (field_size + 4 + 1);
4870   bfd_vma os_flags = 0;
4871   bfd_vma proc_flags = 0;
4872   bfd_vma unknown_flags = 0;
4873   static const struct
4874     {
4875       const char * str;
4876       int len;
4877     }
4878   flags [] =
4879     {
4880       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4881       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4882       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4883       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4884       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4885       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4886       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4887       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4888       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4889       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4890       /* IA-64 specific.  */
4891       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4892       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4893       /* IA-64 OpenVMS specific.  */
4894       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4895       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4896       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4897       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4898       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4899       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4900       /* Generic.  */
4901       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4902       /* SPARC specific.  */
4903       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4904     };
4905
4906   if (do_section_details)
4907     {
4908       sprintf (buff, "[%*.*lx]: ",
4909                field_size, field_size, (unsigned long) sh_flags);
4910       p += field_size + 4;
4911     }
4912
4913   while (sh_flags)
4914     {
4915       bfd_vma flag;
4916
4917       flag = sh_flags & - sh_flags;
4918       sh_flags &= ~ flag;
4919
4920       if (do_section_details)
4921         {
4922           switch (flag)
4923             {
4924             case SHF_WRITE:             sindex = 0; break;
4925             case SHF_ALLOC:             sindex = 1; break;
4926             case SHF_EXECINSTR:         sindex = 2; break;
4927             case SHF_MERGE:             sindex = 3; break;
4928             case SHF_STRINGS:           sindex = 4; break;
4929             case SHF_INFO_LINK:         sindex = 5; break;
4930             case SHF_LINK_ORDER:        sindex = 6; break;
4931             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4932             case SHF_GROUP:             sindex = 8; break;
4933             case SHF_TLS:               sindex = 9; break;
4934             case SHF_EXCLUDE:           sindex = 18; break;
4935
4936             default:
4937               sindex = -1;
4938               switch (elf_header.e_machine)
4939                 {
4940                 case EM_IA_64:
4941                   if (flag == SHF_IA_64_SHORT)
4942                     sindex = 10;
4943                   else if (flag == SHF_IA_64_NORECOV)
4944                     sindex = 11;
4945 #ifdef BFD64
4946                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4947                     switch (flag)
4948                       {
4949                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4950                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4951                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4952                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4953                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4954                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4955                       default:                        break;
4956                       }
4957 #endif
4958                   break;
4959
4960                 case EM_386:
4961                 case EM_486:
4962                 case EM_X86_64:
4963                 case EM_L1OM:
4964                 case EM_K1OM:
4965                 case EM_OLD_SPARCV9:
4966                 case EM_SPARC32PLUS:
4967                 case EM_SPARCV9:
4968                 case EM_SPARC:
4969                   if (flag == SHF_ORDERED)
4970                     sindex = 19;
4971                   break;
4972                 default:
4973                   break;
4974                 }
4975             }
4976
4977           if (sindex != -1)
4978             {
4979               if (p != buff + field_size + 4)
4980                 {
4981                   if (size < (10 + 2))
4982                     abort ();
4983                   size -= 2;
4984                   *p++ = ',';
4985                   *p++ = ' ';
4986                 }
4987
4988               size -= flags [sindex].len;
4989               p = stpcpy (p, flags [sindex].str);
4990             }
4991           else if (flag & SHF_MASKOS)
4992             os_flags |= flag;
4993           else if (flag & SHF_MASKPROC)
4994             proc_flags |= flag;
4995           else
4996             unknown_flags |= flag;
4997         }
4998       else
4999         {
5000           switch (flag)
5001             {
5002             case SHF_WRITE:             *p = 'W'; break;
5003             case SHF_ALLOC:             *p = 'A'; break;
5004             case SHF_EXECINSTR:         *p = 'X'; break;
5005             case SHF_MERGE:             *p = 'M'; break;
5006             case SHF_STRINGS:           *p = 'S'; break;
5007             case SHF_INFO_LINK:         *p = 'I'; break;
5008             case SHF_LINK_ORDER:        *p = 'L'; break;
5009             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5010             case SHF_GROUP:             *p = 'G'; break;
5011             case SHF_TLS:               *p = 'T'; break;
5012             case SHF_EXCLUDE:           *p = 'E'; break;
5013
5014             default:
5015               if ((elf_header.e_machine == EM_X86_64
5016                    || elf_header.e_machine == EM_L1OM
5017                    || elf_header.e_machine == EM_K1OM)
5018                   && flag == SHF_X86_64_LARGE)
5019                 *p = 'l';
5020               else if (flag & SHF_MASKOS)
5021                 {
5022                   *p = 'o';
5023                   sh_flags &= ~ SHF_MASKOS;
5024                 }
5025               else if (flag & SHF_MASKPROC)
5026                 {
5027                   *p = 'p';
5028                   sh_flags &= ~ SHF_MASKPROC;
5029                 }
5030               else
5031                 *p = 'x';
5032               break;
5033             }
5034           p++;
5035         }
5036     }
5037
5038   if (do_section_details)
5039     {
5040       if (os_flags)
5041         {
5042           size -= 5 + field_size;
5043           if (p != buff + field_size + 4)
5044             {
5045               if (size < (2 + 1))
5046                 abort ();
5047               size -= 2;
5048               *p++ = ',';
5049               *p++ = ' ';
5050             }
5051           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5052                    (unsigned long) os_flags);
5053           p += 5 + field_size;
5054         }
5055       if (proc_flags)
5056         {
5057           size -= 7 + field_size;
5058           if (p != buff + field_size + 4)
5059             {
5060               if (size < (2 + 1))
5061                 abort ();
5062               size -= 2;
5063               *p++ = ',';
5064               *p++ = ' ';
5065             }
5066           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5067                    (unsigned long) proc_flags);
5068           p += 7 + field_size;
5069         }
5070       if (unknown_flags)
5071         {
5072           size -= 10 + field_size;
5073           if (p != buff + field_size + 4)
5074             {
5075               if (size < (2 + 1))
5076                 abort ();
5077               size -= 2;
5078               *p++ = ',';
5079               *p++ = ' ';
5080             }
5081           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5082                    (unsigned long) unknown_flags);
5083           p += 10 + field_size;
5084         }
5085     }
5086
5087   *p = '\0';
5088   return buff;
5089 }
5090
5091 static int
5092 process_section_headers (FILE * file)
5093 {
5094   Elf_Internal_Shdr * section;
5095   unsigned int i;
5096
5097   section_headers = NULL;
5098
5099   if (elf_header.e_shnum == 0)
5100     {
5101       /* PR binutils/12467.  */
5102       if (elf_header.e_shoff != 0)
5103         warn (_("possibly corrupt ELF file header - it has a non-zero"
5104                 " section header offset, but no section headers\n"));
5105       else if (do_sections)
5106         printf (_("\nThere are no sections in this file.\n"));
5107
5108       return 1;
5109     }
5110
5111   if (do_sections && !do_header)
5112     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5113             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5114
5115   if (is_32bit_elf)
5116     {
5117       if (! get_32bit_section_headers (file, FALSE))
5118         return 0;
5119     }
5120   else if (! get_64bit_section_headers (file, FALSE))
5121     return 0;
5122
5123   /* Read in the string table, so that we have names to display.  */
5124   if (elf_header.e_shstrndx != SHN_UNDEF
5125        && elf_header.e_shstrndx < elf_header.e_shnum)
5126     {
5127       section = section_headers + elf_header.e_shstrndx;
5128
5129       if (section->sh_size != 0)
5130         {
5131           string_table = (char *) get_data (NULL, file, section->sh_offset,
5132                                             1, section->sh_size,
5133                                             _("string table"));
5134
5135           string_table_length = string_table != NULL ? section->sh_size : 0;
5136         }
5137     }
5138
5139   /* Scan the sections for the dynamic symbol table
5140      and dynamic string table and debug sections.  */
5141   dynamic_symbols = NULL;
5142   dynamic_strings = NULL;
5143   dynamic_syminfo = NULL;
5144   symtab_shndx_hdr = NULL;
5145
5146   eh_addr_size = is_32bit_elf ? 4 : 8;
5147   switch (elf_header.e_machine)
5148     {
5149     case EM_MIPS:
5150     case EM_MIPS_RS3_LE:
5151       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5152          FDE addresses.  However, the ABI also has a semi-official ILP32
5153          variant for which the normal FDE address size rules apply.
5154
5155          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5156          section, where XX is the size of longs in bits.  Unfortunately,
5157          earlier compilers provided no way of distinguishing ILP32 objects
5158          from LP64 objects, so if there's any doubt, we should assume that
5159          the official LP64 form is being used.  */
5160       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5161           && find_section (".gcc_compiled_long32") == NULL)
5162         eh_addr_size = 8;
5163       break;
5164
5165     case EM_H8_300:
5166     case EM_H8_300H:
5167       switch (elf_header.e_flags & EF_H8_MACH)
5168         {
5169         case E_H8_MACH_H8300:
5170         case E_H8_MACH_H8300HN:
5171         case E_H8_MACH_H8300SN:
5172         case E_H8_MACH_H8300SXN:
5173           eh_addr_size = 2;
5174           break;
5175         case E_H8_MACH_H8300H:
5176         case E_H8_MACH_H8300S:
5177         case E_H8_MACH_H8300SX:
5178           eh_addr_size = 4;
5179           break;
5180         }
5181       break;
5182
5183     case EM_M32C_OLD:
5184     case EM_M32C:
5185       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5186         {
5187         case EF_M32C_CPU_M16C:
5188           eh_addr_size = 2;
5189           break;
5190         }
5191       break;
5192     }
5193
5194 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5195   do                                                                    \
5196     {                                                                   \
5197       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5198       if (section->sh_entsize != expected_entsize)                      \
5199         {                                                               \
5200           char buf[40];                                                 \
5201           sprintf_vma (buf, section->sh_entsize);                       \
5202           /* Note: coded this way so that there is a single string for  \
5203              translation.  */ \
5204           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5205           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5206                    (unsigned) expected_entsize);                        \
5207           section->sh_entsize = expected_entsize;                       \
5208         }                                                               \
5209     }                                                                   \
5210   while (0)
5211
5212 #define CHECK_ENTSIZE(section, i, type)                                 \
5213   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5214                         sizeof (Elf64_External_##type))
5215
5216   for (i = 0, section = section_headers;
5217        i < elf_header.e_shnum;
5218        i++, section++)
5219     {
5220       char * name = SECTION_NAME (section);
5221
5222       if (section->sh_type == SHT_DYNSYM)
5223         {
5224           if (dynamic_symbols != NULL)
5225             {
5226               error (_("File contains multiple dynamic symbol tables\n"));
5227               continue;
5228             }
5229
5230           CHECK_ENTSIZE (section, i, Sym);
5231           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5232         }
5233       else if (section->sh_type == SHT_STRTAB
5234                && streq (name, ".dynstr"))
5235         {
5236           if (dynamic_strings != NULL)
5237             {
5238               error (_("File contains multiple dynamic string tables\n"));
5239               continue;
5240             }
5241
5242           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5243                                                1, section->sh_size,
5244                                                _("dynamic strings"));
5245           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5246         }
5247       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5248         {
5249           if (symtab_shndx_hdr != NULL)
5250             {
5251               error (_("File contains multiple symtab shndx tables\n"));
5252               continue;
5253             }
5254           symtab_shndx_hdr = section;
5255         }
5256       else if (section->sh_type == SHT_SYMTAB)
5257         CHECK_ENTSIZE (section, i, Sym);
5258       else if (section->sh_type == SHT_GROUP)
5259         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5260       else if (section->sh_type == SHT_REL)
5261         CHECK_ENTSIZE (section, i, Rel);
5262       else if (section->sh_type == SHT_RELA)
5263         CHECK_ENTSIZE (section, i, Rela);
5264       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5265                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5266                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5267                 || do_debug_str || do_debug_loc || do_debug_ranges
5268                 || do_debug_addr || do_debug_cu_index)
5269                && (const_strneq (name, ".debug_")
5270                    || const_strneq (name, ".zdebug_")))
5271         {
5272           if (name[1] == 'z')
5273             name += sizeof (".zdebug_") - 1;
5274           else
5275             name += sizeof (".debug_") - 1;
5276
5277           if (do_debugging
5278               || (do_debug_info     && const_strneq (name, "info"))
5279               || (do_debug_info     && const_strneq (name, "types"))
5280               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5281               || (do_debug_lines    && strcmp (name, "line") == 0)
5282               || (do_debug_lines    && const_strneq (name, "line."))
5283               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5284               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5285               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5286               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5287               || (do_debug_aranges  && const_strneq (name, "aranges"))
5288               || (do_debug_ranges   && const_strneq (name, "ranges"))
5289               || (do_debug_frames   && const_strneq (name, "frame"))
5290               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5291               || (do_debug_macinfo  && const_strneq (name, "macro"))
5292               || (do_debug_str      && const_strneq (name, "str"))
5293               || (do_debug_loc      && const_strneq (name, "loc"))
5294               || (do_debug_addr     && const_strneq (name, "addr"))
5295               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5296               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5297               )
5298             request_dump_bynumber (i, DEBUG_DUMP);
5299         }
5300       /* Linkonce section to be combined with .debug_info at link time.  */
5301       else if ((do_debugging || do_debug_info)
5302                && const_strneq (name, ".gnu.linkonce.wi."))
5303         request_dump_bynumber (i, DEBUG_DUMP);
5304       else if (do_debug_frames && streq (name, ".eh_frame"))
5305         request_dump_bynumber (i, DEBUG_DUMP);
5306       else if (do_gdb_index && streq (name, ".gdb_index"))
5307         request_dump_bynumber (i, DEBUG_DUMP);
5308       /* Trace sections for Itanium VMS.  */
5309       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5310                 || do_trace_aranges)
5311                && const_strneq (name, ".trace_"))
5312         {
5313           name += sizeof (".trace_") - 1;
5314
5315           if (do_debugging
5316               || (do_trace_info     && streq (name, "info"))
5317               || (do_trace_abbrevs  && streq (name, "abbrev"))
5318               || (do_trace_aranges  && streq (name, "aranges"))
5319               )
5320             request_dump_bynumber (i, DEBUG_DUMP);
5321         }
5322     }
5323
5324   if (! do_sections)
5325     return 1;
5326
5327   if (elf_header.e_shnum > 1)
5328     printf (_("\nSection Headers:\n"));
5329   else
5330     printf (_("\nSection Header:\n"));
5331
5332   if (is_32bit_elf)
5333     {
5334       if (do_section_details)
5335         {
5336           printf (_("  [Nr] Name\n"));
5337           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5338         }
5339       else
5340         printf
5341           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5342     }
5343   else if (do_wide)
5344     {
5345       if (do_section_details)
5346         {
5347           printf (_("  [Nr] Name\n"));
5348           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5349         }
5350       else
5351         printf
5352           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5353     }
5354   else
5355     {
5356       if (do_section_details)
5357         {
5358           printf (_("  [Nr] Name\n"));
5359           printf (_("       Type              Address          Offset            Link\n"));
5360           printf (_("       Size              EntSize          Info              Align\n"));
5361         }
5362       else
5363         {
5364           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5365           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5366         }
5367     }
5368
5369   if (do_section_details)
5370     printf (_("       Flags\n"));
5371
5372   for (i = 0, section = section_headers;
5373        i < elf_header.e_shnum;
5374        i++, section++)
5375     {
5376       printf ("  [%2u] ", i);
5377       if (do_section_details)
5378         printf ("%s\n      ", printable_section_name (section));
5379       else
5380         print_symbol (-17, SECTION_NAME (section));
5381
5382       printf (do_wide ? " %-15s " : " %-15.15s ",
5383               get_section_type_name (section->sh_type));
5384
5385       if (is_32bit_elf)
5386         {
5387           const char * link_too_big = NULL;
5388
5389           print_vma (section->sh_addr, LONG_HEX);
5390
5391           printf ( " %6.6lx %6.6lx %2.2lx",
5392                    (unsigned long) section->sh_offset,
5393                    (unsigned long) section->sh_size,
5394                    (unsigned long) section->sh_entsize);
5395
5396           if (do_section_details)
5397             fputs ("  ", stdout);
5398           else
5399             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5400
5401           if (section->sh_link >= elf_header.e_shnum)
5402             {
5403               link_too_big = "";
5404               /* The sh_link value is out of range.  Normally this indicates
5405                  an error but it can have special values in Solaris binaries.  */
5406               switch (elf_header.e_machine)
5407                 {
5408                 case EM_386:
5409                 case EM_486:
5410                 case EM_X86_64:
5411                 case EM_L1OM:
5412                 case EM_K1OM:
5413                 case EM_OLD_SPARCV9:
5414                 case EM_SPARC32PLUS:
5415                 case EM_SPARCV9:
5416                 case EM_SPARC:
5417                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5418                     link_too_big = "BEFORE";
5419                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5420                     link_too_big = "AFTER";
5421                   break;
5422                 default:
5423                   break;
5424                 }
5425             }
5426
5427           if (do_section_details)
5428             {
5429               if (link_too_big != NULL && * link_too_big)
5430                 printf ("<%s> ", link_too_big);
5431               else
5432                 printf ("%2u ", section->sh_link);
5433               printf ("%3u %2lu\n", section->sh_info,
5434                       (unsigned long) section->sh_addralign);
5435             }
5436           else
5437             printf ("%2u %3u %2lu\n",
5438                     section->sh_link,
5439                     section->sh_info,
5440                     (unsigned long) section->sh_addralign);
5441
5442           if (link_too_big && ! * link_too_big)
5443             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5444                   i, section->sh_link);
5445         }
5446       else if (do_wide)
5447         {
5448           print_vma (section->sh_addr, LONG_HEX);
5449
5450           if ((long) section->sh_offset == section->sh_offset)
5451             printf (" %6.6lx", (unsigned long) section->sh_offset);
5452           else
5453             {
5454               putchar (' ');
5455               print_vma (section->sh_offset, LONG_HEX);
5456             }
5457
5458           if ((unsigned long) section->sh_size == section->sh_size)
5459             printf (" %6.6lx", (unsigned long) section->sh_size);
5460           else
5461             {
5462               putchar (' ');
5463               print_vma (section->sh_size, LONG_HEX);
5464             }
5465
5466           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5467             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5468           else
5469             {
5470               putchar (' ');
5471               print_vma (section->sh_entsize, LONG_HEX);
5472             }
5473
5474           if (do_section_details)
5475             fputs ("  ", stdout);
5476           else
5477             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5478
5479           printf ("%2u %3u ", section->sh_link, section->sh_info);
5480
5481           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5482             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5483           else
5484             {
5485               print_vma (section->sh_addralign, DEC);
5486               putchar ('\n');
5487             }
5488         }
5489       else if (do_section_details)
5490         {
5491           printf ("       %-15.15s  ",
5492                   get_section_type_name (section->sh_type));
5493           print_vma (section->sh_addr, LONG_HEX);
5494           if ((long) section->sh_offset == section->sh_offset)
5495             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5496           else
5497             {
5498               printf ("  ");
5499               print_vma (section->sh_offset, LONG_HEX);
5500             }
5501           printf ("  %u\n       ", section->sh_link);
5502           print_vma (section->sh_size, LONG_HEX);
5503           putchar (' ');
5504           print_vma (section->sh_entsize, LONG_HEX);
5505
5506           printf ("  %-16u  %lu\n",
5507                   section->sh_info,
5508                   (unsigned long) section->sh_addralign);
5509         }
5510       else
5511         {
5512           putchar (' ');
5513           print_vma (section->sh_addr, LONG_HEX);
5514           if ((long) section->sh_offset == section->sh_offset)
5515             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5516           else
5517             {
5518               printf ("  ");
5519               print_vma (section->sh_offset, LONG_HEX);
5520             }
5521           printf ("\n       ");
5522           print_vma (section->sh_size, LONG_HEX);
5523           printf ("  ");
5524           print_vma (section->sh_entsize, LONG_HEX);
5525
5526           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5527
5528           printf ("     %2u   %3u     %lu\n",
5529                   section->sh_link,
5530                   section->sh_info,
5531                   (unsigned long) section->sh_addralign);
5532         }
5533
5534       if (do_section_details)
5535         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5536     }
5537
5538   if (!do_section_details)
5539     {
5540       if (elf_header.e_machine == EM_X86_64
5541           || elf_header.e_machine == EM_L1OM
5542           || elf_header.e_machine == EM_K1OM)
5543         printf (_("Key to Flags:\n\
5544   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5545   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5546   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5547       else
5548         printf (_("Key to Flags:\n\
5549   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5550   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5551   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5552     }
5553
5554   return 1;
5555 }
5556
5557 static const char *
5558 get_group_flags (unsigned int flags)
5559 {
5560   static char buff[32];
5561   switch (flags)
5562     {
5563     case 0:
5564       return "";
5565
5566     case GRP_COMDAT:
5567       return "COMDAT ";
5568
5569    default:
5570       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5571       break;
5572     }
5573   return buff;
5574 }
5575
5576 static int
5577 process_section_groups (FILE * file)
5578 {
5579   Elf_Internal_Shdr * section;
5580   unsigned int i;
5581   struct group * group;
5582   Elf_Internal_Shdr * symtab_sec;
5583   Elf_Internal_Shdr * strtab_sec;
5584   Elf_Internal_Sym * symtab;
5585   unsigned long num_syms;
5586   char * strtab;
5587   size_t strtab_size;
5588
5589   /* Don't process section groups unless needed.  */
5590   if (!do_unwind && !do_section_groups)
5591     return 1;
5592
5593   if (elf_header.e_shnum == 0)
5594     {
5595       if (do_section_groups)
5596         printf (_("\nThere are no sections to group in this file.\n"));
5597
5598       return 1;
5599     }
5600
5601   if (section_headers == NULL)
5602     {
5603       error (_("Section headers are not available!\n"));
5604       /* PR 13622: This can happen with a corrupt ELF header.  */
5605       return 0;
5606     }
5607
5608   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5609                                                      sizeof (struct group *));
5610
5611   if (section_headers_groups == NULL)
5612     {
5613       error (_("Out of memory\n"));
5614       return 0;
5615     }
5616
5617   /* Scan the sections for the group section.  */
5618   group_count = 0;
5619   for (i = 0, section = section_headers;
5620        i < elf_header.e_shnum;
5621        i++, section++)
5622     if (section->sh_type == SHT_GROUP)
5623       group_count++;
5624
5625   if (group_count == 0)
5626     {
5627       if (do_section_groups)
5628         printf (_("\nThere are no section groups in this file.\n"));
5629
5630       return 1;
5631     }
5632
5633   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5634
5635   if (section_groups == NULL)
5636     {
5637       error (_("Out of memory\n"));
5638       return 0;
5639     }
5640
5641   symtab_sec = NULL;
5642   strtab_sec = NULL;
5643   symtab = NULL;
5644   num_syms = 0;
5645   strtab = NULL;
5646   strtab_size = 0;
5647   for (i = 0, section = section_headers, group = section_groups;
5648        i < elf_header.e_shnum;
5649        i++, section++)
5650     {
5651       if (section->sh_type == SHT_GROUP)
5652         {
5653           const char * name = printable_section_name (section);
5654           const char * group_name;
5655           unsigned char * start;
5656           unsigned char * indices;
5657           unsigned int entry, j, size;
5658           Elf_Internal_Shdr * sec;
5659           Elf_Internal_Sym * sym;
5660
5661           /* Get the symbol table.  */
5662           if (section->sh_link >= elf_header.e_shnum
5663               || ((sec = section_headers + section->sh_link)->sh_type
5664                   != SHT_SYMTAB))
5665             {
5666               error (_("Bad sh_link in group section `%s'\n"), name);
5667               continue;
5668             }
5669
5670           if (symtab_sec != sec)
5671             {
5672               symtab_sec = sec;
5673               if (symtab)
5674                 free (symtab);
5675               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5676             }
5677
5678           if (symtab == NULL)
5679             {
5680               error (_("Corrupt header in group section `%s'\n"), name);
5681               continue;
5682             }
5683
5684           if (section->sh_info >= num_syms)
5685             {
5686               error (_("Bad sh_info in group section `%s'\n"), name);
5687               continue;
5688             }
5689
5690           sym = symtab + section->sh_info;
5691
5692           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5693             {
5694               if (sym->st_shndx == 0
5695                   || sym->st_shndx >= elf_header.e_shnum)
5696                 {
5697                   error (_("Bad sh_info in group section `%s'\n"), name);
5698                   continue;
5699                 }
5700
5701               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5702               strtab_sec = NULL;
5703               if (strtab)
5704                 free (strtab);
5705               strtab = NULL;
5706               strtab_size = 0;
5707             }
5708           else
5709             {
5710               /* Get the string table.  */
5711               if (symtab_sec->sh_link >= elf_header.e_shnum)
5712                 {
5713                   strtab_sec = NULL;
5714                   if (strtab)
5715                     free (strtab);
5716                   strtab = NULL;
5717                   strtab_size = 0;
5718                 }
5719               else if (strtab_sec
5720                        != (sec = section_headers + symtab_sec->sh_link))
5721                 {
5722                   strtab_sec = sec;
5723                   if (strtab)
5724                     free (strtab);
5725                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5726                                               1, strtab_sec->sh_size,
5727                                               _("string table"));
5728                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5729                 }
5730               group_name = sym->st_name < strtab_size
5731                 ? strtab + sym->st_name : _("<corrupt>");
5732             }
5733
5734           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5735                                               1, section->sh_size,
5736                                               _("section data"));
5737           if (start == NULL)
5738             continue;
5739
5740           indices = start;
5741           size = (section->sh_size / section->sh_entsize) - 1;
5742           entry = byte_get (indices, 4);
5743           indices += 4;
5744
5745           if (do_section_groups)
5746             {
5747               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5748                       get_group_flags (entry), i, name, group_name, size);
5749
5750               printf (_("   [Index]    Name\n"));
5751             }
5752
5753           group->group_index = i;
5754
5755           for (j = 0; j < size; j++)
5756             {
5757               struct group_list * g;
5758
5759               entry = byte_get (indices, 4);
5760               indices += 4;
5761
5762               if (entry >= elf_header.e_shnum)
5763                 {
5764                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5765                          entry, i, elf_header.e_shnum - 1);
5766                   continue;
5767                 }
5768
5769               if (section_headers_groups [entry] != NULL)
5770                 {
5771                   if (entry)
5772                     {
5773                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5774                              entry, i,
5775                              section_headers_groups [entry]->group_index);
5776                       continue;
5777                     }
5778                   else
5779                     {
5780                       /* Intel C/C++ compiler may put section 0 in a
5781                          section group. We just warn it the first time
5782                          and ignore it afterwards.  */
5783                       static int warned = 0;
5784                       if (!warned)
5785                         {
5786                           error (_("section 0 in group section [%5u]\n"),
5787                                  section_headers_groups [entry]->group_index);
5788                           warned++;
5789                         }
5790                     }
5791                 }
5792
5793               section_headers_groups [entry] = group;
5794
5795               if (do_section_groups)
5796                 {
5797                   sec = section_headers + entry;
5798                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
5799                 }
5800
5801               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5802               g->section_index = entry;
5803               g->next = group->root;
5804               group->root = g;
5805             }
5806
5807           if (start)
5808             free (start);
5809
5810           group++;
5811         }
5812     }
5813
5814   if (symtab)
5815     free (symtab);
5816   if (strtab)
5817     free (strtab);
5818   return 1;
5819 }
5820
5821 /* Data used to display dynamic fixups.  */
5822
5823 struct ia64_vms_dynfixup
5824 {
5825   bfd_vma needed_ident;         /* Library ident number.  */
5826   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5827   bfd_vma fixup_needed;         /* Index of the library.  */
5828   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5829   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5830 };
5831
5832 /* Data used to display dynamic relocations.  */
5833
5834 struct ia64_vms_dynimgrela
5835 {
5836   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5837   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5838 };
5839
5840 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5841    library).  */
5842
5843 static void
5844 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5845                               const char *strtab, unsigned int strtab_sz)
5846 {
5847   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5848   long i;
5849   const char *lib_name;
5850
5851   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5852                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5853                    _("dynamic section image fixups"));
5854   if (!imfs)
5855     return;
5856
5857   if (fixup->needed < strtab_sz)
5858     lib_name = strtab + fixup->needed;
5859   else
5860     {
5861       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5862             (unsigned long) fixup->needed);
5863       lib_name = "???";
5864     }
5865   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5866           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5867   printf
5868     (_("Seg Offset           Type                             SymVec DataType\n"));
5869
5870   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5871     {
5872       unsigned int type;
5873       const char *rtype;
5874
5875       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5876       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5877       type = BYTE_GET (imfs [i].type);
5878       rtype = elf_ia64_reloc_type (type);
5879       if (rtype == NULL)
5880         printf (" 0x%08x                       ", type);
5881       else
5882         printf (" %-32s ", rtype);
5883       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5884       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5885     }
5886
5887   free (imfs);
5888 }
5889
5890 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5891
5892 static void
5893 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5894 {
5895   Elf64_External_VMS_IMAGE_RELA *imrs;
5896   long i;
5897
5898   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5899                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5900                    _("dynamic section image relocations"));
5901   if (!imrs)
5902     return;
5903
5904   printf (_("\nImage relocs\n"));
5905   printf
5906     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5907
5908   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5909     {
5910       unsigned int type;
5911       const char *rtype;
5912
5913       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5914       printf ("%08" BFD_VMA_FMT "x ",
5915               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5916       type = BYTE_GET (imrs [i].type);
5917       rtype = elf_ia64_reloc_type (type);
5918       if (rtype == NULL)
5919         printf ("0x%08x                      ", type);
5920       else
5921         printf ("%-31s ", rtype);
5922       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5923       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5924       printf ("%08" BFD_VMA_FMT "x\n",
5925               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5926     }
5927
5928   free (imrs);
5929 }
5930
5931 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5932
5933 static int
5934 process_ia64_vms_dynamic_relocs (FILE *file)
5935 {
5936   struct ia64_vms_dynfixup fixup;
5937   struct ia64_vms_dynimgrela imgrela;
5938   Elf_Internal_Dyn *entry;
5939   int res = 0;
5940   bfd_vma strtab_off = 0;
5941   bfd_vma strtab_sz = 0;
5942   char *strtab = NULL;
5943
5944   memset (&fixup, 0, sizeof (fixup));
5945   memset (&imgrela, 0, sizeof (imgrela));
5946
5947   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5948   for (entry = dynamic_section;
5949        entry < dynamic_section + dynamic_nent;
5950        entry++)
5951     {
5952       switch (entry->d_tag)
5953         {
5954         case DT_IA_64_VMS_STRTAB_OFFSET:
5955           strtab_off = entry->d_un.d_val;
5956           break;
5957         case DT_STRSZ:
5958           strtab_sz = entry->d_un.d_val;
5959           if (strtab == NULL)
5960             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5961                                1, strtab_sz, _("dynamic string section"));
5962           break;
5963
5964         case DT_IA_64_VMS_NEEDED_IDENT:
5965           fixup.needed_ident = entry->d_un.d_val;
5966           break;
5967         case DT_NEEDED:
5968           fixup.needed = entry->d_un.d_val;
5969           break;
5970         case DT_IA_64_VMS_FIXUP_NEEDED:
5971           fixup.fixup_needed = entry->d_un.d_val;
5972           break;
5973         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5974           fixup.fixup_rela_cnt = entry->d_un.d_val;
5975           break;
5976         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5977           fixup.fixup_rela_off = entry->d_un.d_val;
5978           res++;
5979           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5980           break;
5981
5982         case DT_IA_64_VMS_IMG_RELA_CNT:
5983           imgrela.img_rela_cnt = entry->d_un.d_val;
5984           break;
5985         case DT_IA_64_VMS_IMG_RELA_OFF:
5986           imgrela.img_rela_off = entry->d_un.d_val;
5987           res++;
5988           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5989           break;
5990
5991         default:
5992           break;
5993         }
5994     }
5995
5996   if (strtab != NULL)
5997     free (strtab);
5998
5999   return res;
6000 }
6001
6002 static struct
6003 {
6004   const char * name;
6005   int reloc;
6006   int size;
6007   int rela;
6008 } dynamic_relocations [] =
6009 {
6010     { "REL", DT_REL, DT_RELSZ, FALSE },
6011     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6012     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6013 };
6014
6015 /* Process the reloc section.  */
6016
6017 static int
6018 process_relocs (FILE * file)
6019 {
6020   unsigned long rel_size;
6021   unsigned long rel_offset;
6022
6023
6024   if (!do_reloc)
6025     return 1;
6026
6027   if (do_using_dynamic)
6028     {
6029       int is_rela;
6030       const char * name;
6031       int has_dynamic_reloc;
6032       unsigned int i;
6033
6034       has_dynamic_reloc = 0;
6035
6036       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6037         {
6038           is_rela = dynamic_relocations [i].rela;
6039           name = dynamic_relocations [i].name;
6040           rel_size = dynamic_info [dynamic_relocations [i].size];
6041           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6042
6043           has_dynamic_reloc |= rel_size;
6044
6045           if (is_rela == UNKNOWN)
6046             {
6047               if (dynamic_relocations [i].reloc == DT_JMPREL)
6048                 switch (dynamic_info[DT_PLTREL])
6049                   {
6050                   case DT_REL:
6051                     is_rela = FALSE;
6052                     break;
6053                   case DT_RELA:
6054                     is_rela = TRUE;
6055                     break;
6056                   }
6057             }
6058
6059           if (rel_size)
6060             {
6061               printf
6062                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6063                  name, rel_offset, rel_size);
6064
6065               dump_relocations (file,
6066                                 offset_from_vma (file, rel_offset, rel_size),
6067                                 rel_size,
6068                                 dynamic_symbols, num_dynamic_syms,
6069                                 dynamic_strings, dynamic_strings_length, is_rela);
6070             }
6071         }
6072
6073       if (is_ia64_vms ())
6074         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6075
6076       if (! has_dynamic_reloc)
6077         printf (_("\nThere are no dynamic relocations in this file.\n"));
6078     }
6079   else
6080     {
6081       Elf_Internal_Shdr * section;
6082       unsigned long i;
6083       int found = 0;
6084
6085       for (i = 0, section = section_headers;
6086            i < elf_header.e_shnum;
6087            i++, section++)
6088         {
6089           if (   section->sh_type != SHT_RELA
6090               && section->sh_type != SHT_REL)
6091             continue;
6092
6093           rel_offset = section->sh_offset;
6094           rel_size   = section->sh_size;
6095
6096           if (rel_size)
6097             {
6098               Elf_Internal_Shdr * strsec;
6099               int is_rela;
6100
6101               printf (_("\nRelocation section "));
6102
6103               if (string_table == NULL)
6104                 printf ("%d", section->sh_name);
6105               else
6106                 printf ("'%s'", printable_section_name (section));
6107
6108               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6109                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6110
6111               is_rela = section->sh_type == SHT_RELA;
6112
6113               if (section->sh_link != 0
6114                   && section->sh_link < elf_header.e_shnum)
6115                 {
6116                   Elf_Internal_Shdr * symsec;
6117                   Elf_Internal_Sym *  symtab;
6118                   unsigned long nsyms;
6119                   unsigned long strtablen = 0;
6120                   char * strtab = NULL;
6121
6122                   symsec = section_headers + section->sh_link;
6123                   if (symsec->sh_type != SHT_SYMTAB
6124                       && symsec->sh_type != SHT_DYNSYM)
6125                     continue;
6126
6127                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6128
6129                   if (symtab == NULL)
6130                     continue;
6131
6132                   if (symsec->sh_link != 0
6133                       && symsec->sh_link < elf_header.e_shnum)
6134                     {
6135                       strsec = section_headers + symsec->sh_link;
6136
6137                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6138                                                   1, strsec->sh_size,
6139                                                   _("string table"));
6140                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6141                     }
6142
6143                   dump_relocations (file, rel_offset, rel_size,
6144                                     symtab, nsyms, strtab, strtablen, is_rela);
6145                   if (strtab)
6146                     free (strtab);
6147                   free (symtab);
6148                 }
6149               else
6150                 dump_relocations (file, rel_offset, rel_size,
6151                                   NULL, 0, NULL, 0, is_rela);
6152
6153               found = 1;
6154             }
6155         }
6156
6157       if (! found)
6158         printf (_("\nThere are no relocations in this file.\n"));
6159     }
6160
6161   return 1;
6162 }
6163
6164 /* Process the unwind section.  */
6165
6166 #include "unwind-ia64.h"
6167
6168 /* An absolute address consists of a section and an offset.  If the
6169    section is NULL, the offset itself is the address, otherwise, the
6170    address equals to LOAD_ADDRESS(section) + offset.  */
6171
6172 struct absaddr
6173   {
6174     unsigned short section;
6175     bfd_vma offset;
6176   };
6177
6178 #define ABSADDR(a) \
6179   ((a).section \
6180    ? section_headers [(a).section].sh_addr + (a).offset \
6181    : (a).offset)
6182
6183 struct ia64_unw_table_entry
6184   {
6185     struct absaddr start;
6186     struct absaddr end;
6187     struct absaddr info;
6188   };
6189
6190 struct ia64_unw_aux_info
6191   {
6192
6193     struct ia64_unw_table_entry *table; /* Unwind table.  */
6194     unsigned long table_len;    /* Length of unwind table.  */
6195     unsigned char * info;       /* Unwind info.  */
6196     unsigned long info_size;    /* Size of unwind info.  */
6197     bfd_vma info_addr;          /* starting address of unwind info.  */
6198     bfd_vma seg_base;           /* Starting address of segment.  */
6199     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6200     unsigned long nsyms;        /* Number of symbols.  */
6201     char * strtab;              /* The string table.  */
6202     unsigned long strtab_size;  /* Size of string table.  */
6203   };
6204
6205 static void
6206 find_symbol_for_address (Elf_Internal_Sym * symtab,
6207                          unsigned long nsyms,
6208                          const char * strtab,
6209                          unsigned long strtab_size,
6210                          struct absaddr addr,
6211                          const char ** symname,
6212                          bfd_vma * offset)
6213 {
6214   bfd_vma dist = 0x100000;
6215   Elf_Internal_Sym * sym;
6216   Elf_Internal_Sym * best = NULL;
6217   unsigned long i;
6218
6219   REMOVE_ARCH_BITS (addr.offset);
6220
6221   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6222     {
6223       bfd_vma value = sym->st_value;
6224
6225       REMOVE_ARCH_BITS (value);
6226
6227       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6228           && sym->st_name != 0
6229           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6230           && addr.offset >= value
6231           && addr.offset - value < dist)
6232         {
6233           best = sym;
6234           dist = addr.offset - value;
6235           if (!dist)
6236             break;
6237         }
6238     }
6239
6240   if (best)
6241     {
6242       *symname = (best->st_name >= strtab_size
6243                   ? _("<corrupt>") : strtab + best->st_name);
6244       *offset = dist;
6245       return;
6246     }
6247
6248   *symname = NULL;
6249   *offset = addr.offset;
6250 }
6251
6252 static void
6253 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6254 {
6255   struct ia64_unw_table_entry * tp;
6256   int in_body;
6257
6258   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6259     {
6260       bfd_vma stamp;
6261       bfd_vma offset;
6262       const unsigned char * dp;
6263       const unsigned char * head;
6264       const char * procname;
6265
6266       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6267                                aux->strtab_size, tp->start, &procname, &offset);
6268
6269       fputs ("\n<", stdout);
6270
6271       if (procname)
6272         {
6273           fputs (procname, stdout);
6274
6275           if (offset)
6276             printf ("+%lx", (unsigned long) offset);
6277         }
6278
6279       fputs (">: [", stdout);
6280       print_vma (tp->start.offset, PREFIX_HEX);
6281       fputc ('-', stdout);
6282       print_vma (tp->end.offset, PREFIX_HEX);
6283       printf ("], info at +0x%lx\n",
6284               (unsigned long) (tp->info.offset - aux->seg_base));
6285
6286       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6287       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6288
6289       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6290               (unsigned) UNW_VER (stamp),
6291               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6292               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6293               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6294               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6295
6296       if (UNW_VER (stamp) != 1)
6297         {
6298           printf (_("\tUnknown version.\n"));
6299           continue;
6300         }
6301
6302       in_body = 0;
6303       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6304         dp = unw_decode (dp, in_body, & in_body);
6305     }
6306 }
6307
6308 static int
6309 slurp_ia64_unwind_table (FILE * file,
6310                          struct ia64_unw_aux_info * aux,
6311                          Elf_Internal_Shdr * sec)
6312 {
6313   unsigned long size, nrelas, i;
6314   Elf_Internal_Phdr * seg;
6315   struct ia64_unw_table_entry * tep;
6316   Elf_Internal_Shdr * relsec;
6317   Elf_Internal_Rela * rela;
6318   Elf_Internal_Rela * rp;
6319   unsigned char * table;
6320   unsigned char * tp;
6321   Elf_Internal_Sym * sym;
6322   const char * relname;
6323
6324   /* First, find the starting address of the segment that includes
6325      this section: */
6326
6327   if (elf_header.e_phnum)
6328     {
6329       if (! get_program_headers (file))
6330           return 0;
6331
6332       for (seg = program_headers;
6333            seg < program_headers + elf_header.e_phnum;
6334            ++seg)
6335         {
6336           if (seg->p_type != PT_LOAD)
6337             continue;
6338
6339           if (sec->sh_addr >= seg->p_vaddr
6340               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6341             {
6342               aux->seg_base = seg->p_vaddr;
6343               break;
6344             }
6345         }
6346     }
6347
6348   /* Second, build the unwind table from the contents of the unwind section:  */
6349   size = sec->sh_size;
6350   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6351                                       _("unwind table"));
6352   if (!table)
6353     return 0;
6354
6355   aux->table = (struct ia64_unw_table_entry *)
6356       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6357   tep = aux->table;
6358   for (tp = table; tp < table + size; ++tep)
6359     {
6360       tep->start.section = SHN_UNDEF;
6361       tep->end.section   = SHN_UNDEF;
6362       tep->info.section  = SHN_UNDEF;
6363       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6364       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6365       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6366       tep->start.offset += aux->seg_base;
6367       tep->end.offset   += aux->seg_base;
6368       tep->info.offset  += aux->seg_base;
6369     }
6370   free (table);
6371
6372   /* Third, apply any relocations to the unwind table:  */
6373   for (relsec = section_headers;
6374        relsec < section_headers + elf_header.e_shnum;
6375        ++relsec)
6376     {
6377       if (relsec->sh_type != SHT_RELA
6378           || relsec->sh_info >= elf_header.e_shnum
6379           || section_headers + relsec->sh_info != sec)
6380         continue;
6381
6382       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6383                               & rela, & nrelas))
6384         return 0;
6385
6386       for (rp = rela; rp < rela + nrelas; ++rp)
6387         {
6388           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6389           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6390
6391           if (! const_strneq (relname, "R_IA64_SEGREL"))
6392             {
6393               warn (_("Skipping unexpected relocation type %s\n"), relname);
6394               continue;
6395             }
6396
6397           i = rp->r_offset / (3 * eh_addr_size);
6398
6399           switch (rp->r_offset/eh_addr_size % 3)
6400             {
6401             case 0:
6402               aux->table[i].start.section = sym->st_shndx;
6403               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6404               break;
6405             case 1:
6406               aux->table[i].end.section   = sym->st_shndx;
6407               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6408               break;
6409             case 2:
6410               aux->table[i].info.section  = sym->st_shndx;
6411               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6412               break;
6413             default:
6414               break;
6415             }
6416         }
6417
6418       free (rela);
6419     }
6420
6421   aux->table_len = size / (3 * eh_addr_size);
6422   return 1;
6423 }
6424
6425 static void
6426 ia64_process_unwind (FILE * file)
6427 {
6428   Elf_Internal_Shdr * sec;
6429   Elf_Internal_Shdr * unwsec = NULL;
6430   Elf_Internal_Shdr * strsec;
6431   unsigned long i, unwcount = 0, unwstart = 0;
6432   struct ia64_unw_aux_info aux;
6433
6434   memset (& aux, 0, sizeof (aux));
6435
6436   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6437     {
6438       if (sec->sh_type == SHT_SYMTAB
6439           && sec->sh_link < elf_header.e_shnum)
6440         {
6441           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6442
6443           strsec = section_headers + sec->sh_link;
6444           assert (aux.strtab == NULL);
6445           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6446                                           1, strsec->sh_size,
6447                                           _("string table"));
6448           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6449         }
6450       else if (sec->sh_type == SHT_IA_64_UNWIND)
6451         unwcount++;
6452     }
6453
6454   if (!unwcount)
6455     printf (_("\nThere are no unwind sections in this file.\n"));
6456
6457   while (unwcount-- > 0)
6458     {
6459       char * suffix;
6460       size_t len, len2;
6461
6462       for (i = unwstart, sec = section_headers + unwstart;
6463            i < elf_header.e_shnum; ++i, ++sec)
6464         if (sec->sh_type == SHT_IA_64_UNWIND)
6465           {
6466             unwsec = sec;
6467             break;
6468           }
6469
6470       unwstart = i + 1;
6471       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6472
6473       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6474         {
6475           /* We need to find which section group it is in.  */
6476           struct group_list * g = section_headers_groups [i]->root;
6477
6478           for (; g != NULL; g = g->next)
6479             {
6480               sec = section_headers + g->section_index;
6481
6482               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6483                 break;
6484             }
6485
6486           if (g == NULL)
6487             i = elf_header.e_shnum;
6488         }
6489       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6490         {
6491           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6492           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6493           suffix = SECTION_NAME (unwsec) + len;
6494           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6495                ++i, ++sec)
6496             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6497                 && streq (SECTION_NAME (sec) + len2, suffix))
6498               break;
6499         }
6500       else
6501         {
6502           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6503              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6504           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6505           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6506           suffix = "";
6507           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6508             suffix = SECTION_NAME (unwsec) + len;
6509           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6510                ++i, ++sec)
6511             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6512                 && streq (SECTION_NAME (sec) + len2, suffix))
6513               break;
6514         }
6515
6516       if (i == elf_header.e_shnum)
6517         {
6518           printf (_("\nCould not find unwind info section for "));
6519
6520           if (string_table == NULL)
6521             printf ("%d", unwsec->sh_name);
6522           else
6523             printf ("'%s'", printable_section_name (unwsec));
6524         }
6525       else
6526         {
6527           aux.info_addr = sec->sh_addr;
6528           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6529                                                  sec->sh_size,
6530                                                  _("unwind info"));
6531           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6532
6533           printf (_("\nUnwind section "));
6534
6535           if (string_table == NULL)
6536             printf ("%d", unwsec->sh_name);
6537           else
6538             printf ("'%s'", printable_section_name (unwsec));
6539
6540           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6541                   (unsigned long) unwsec->sh_offset,
6542                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6543
6544           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6545
6546           if (aux.table_len > 0)
6547             dump_ia64_unwind (& aux);
6548
6549           if (aux.table)
6550             free ((char *) aux.table);
6551           if (aux.info)
6552             free ((char *) aux.info);
6553           aux.table = NULL;
6554           aux.info = NULL;
6555         }
6556     }
6557
6558   if (aux.symtab)
6559     free (aux.symtab);
6560   if (aux.strtab)
6561     free ((char *) aux.strtab);
6562 }
6563
6564 struct hppa_unw_table_entry
6565   {
6566     struct absaddr start;
6567     struct absaddr end;
6568     unsigned int Cannot_unwind:1;                       /* 0 */
6569     unsigned int Millicode:1;                   /* 1 */
6570     unsigned int Millicode_save_sr0:1;          /* 2 */
6571     unsigned int Region_description:2;          /* 3..4 */
6572     unsigned int reserved1:1;                   /* 5 */
6573     unsigned int Entry_SR:1;                    /* 6 */
6574     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6575     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6576     unsigned int Args_stored:1;                 /* 16 */
6577     unsigned int Variable_Frame:1;                      /* 17 */
6578     unsigned int Separate_Package_Body:1;               /* 18 */
6579     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6580     unsigned int Stack_Overflow_Check:1;                /* 20 */
6581     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6582     unsigned int Ada_Region:1;                  /* 22 */
6583     unsigned int cxx_info:1;                    /* 23 */
6584     unsigned int cxx_try_catch:1;                       /* 24 */
6585     unsigned int sched_entry_seq:1;                     /* 25 */
6586     unsigned int reserved2:1;                   /* 26 */
6587     unsigned int Save_SP:1;                             /* 27 */
6588     unsigned int Save_RP:1;                             /* 28 */
6589     unsigned int Save_MRP_in_frame:1;           /* 29 */
6590     unsigned int extn_ptr_defined:1;            /* 30 */
6591     unsigned int Cleanup_defined:1;                     /* 31 */
6592
6593     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6594     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6595     unsigned int Large_frame:1;                 /* 2 */
6596     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6597     unsigned int reserved4:1;                   /* 4 */
6598     unsigned int Total_frame_size:27;           /* 5..31 */
6599   };
6600
6601 struct hppa_unw_aux_info
6602   {
6603     struct hppa_unw_table_entry *table; /* Unwind table.  */
6604     unsigned long table_len;    /* Length of unwind table.  */
6605     bfd_vma seg_base;           /* Starting address of segment.  */
6606     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6607     unsigned long nsyms;        /* Number of symbols.  */
6608     char * strtab;              /* The string table.  */
6609     unsigned long strtab_size;  /* Size of string table.  */
6610   };
6611
6612 static void
6613 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6614 {
6615   struct hppa_unw_table_entry * tp;
6616
6617   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6618     {
6619       bfd_vma offset;
6620       const char * procname;
6621
6622       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6623                                aux->strtab_size, tp->start, &procname,
6624                                &offset);
6625
6626       fputs ("\n<", stdout);
6627
6628       if (procname)
6629         {
6630           fputs (procname, stdout);
6631
6632           if (offset)
6633             printf ("+%lx", (unsigned long) offset);
6634         }
6635
6636       fputs (">: [", stdout);
6637       print_vma (tp->start.offset, PREFIX_HEX);
6638       fputc ('-', stdout);
6639       print_vma (tp->end.offset, PREFIX_HEX);
6640       printf ("]\n\t");
6641
6642 #define PF(_m) if (tp->_m) printf (#_m " ");
6643 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6644       PF(Cannot_unwind);
6645       PF(Millicode);
6646       PF(Millicode_save_sr0);
6647       /* PV(Region_description);  */
6648       PF(Entry_SR);
6649       PV(Entry_FR);
6650       PV(Entry_GR);
6651       PF(Args_stored);
6652       PF(Variable_Frame);
6653       PF(Separate_Package_Body);
6654       PF(Frame_Extension_Millicode);
6655       PF(Stack_Overflow_Check);
6656       PF(Two_Instruction_SP_Increment);
6657       PF(Ada_Region);
6658       PF(cxx_info);
6659       PF(cxx_try_catch);
6660       PF(sched_entry_seq);
6661       PF(Save_SP);
6662       PF(Save_RP);
6663       PF(Save_MRP_in_frame);
6664       PF(extn_ptr_defined);
6665       PF(Cleanup_defined);
6666       PF(MPE_XL_interrupt_marker);
6667       PF(HP_UX_interrupt_marker);
6668       PF(Large_frame);
6669       PF(Pseudo_SP_Set);
6670       PV(Total_frame_size);
6671 #undef PF
6672 #undef PV
6673     }
6674
6675   printf ("\n");
6676 }
6677
6678 static int
6679 slurp_hppa_unwind_table (FILE * file,
6680                          struct hppa_unw_aux_info * aux,
6681                          Elf_Internal_Shdr * sec)
6682 {
6683   unsigned long size, unw_ent_size, nentries, nrelas, i;
6684   Elf_Internal_Phdr * seg;
6685   struct hppa_unw_table_entry * tep;
6686   Elf_Internal_Shdr * relsec;
6687   Elf_Internal_Rela * rela;
6688   Elf_Internal_Rela * rp;
6689   unsigned char * table;
6690   unsigned char * tp;
6691   Elf_Internal_Sym * sym;
6692   const char * relname;
6693
6694   /* First, find the starting address of the segment that includes
6695      this section.  */
6696
6697   if (elf_header.e_phnum)
6698     {
6699       if (! get_program_headers (file))
6700         return 0;
6701
6702       for (seg = program_headers;
6703            seg < program_headers + elf_header.e_phnum;
6704            ++seg)
6705         {
6706           if (seg->p_type != PT_LOAD)
6707             continue;
6708
6709           if (sec->sh_addr >= seg->p_vaddr
6710               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6711             {
6712               aux->seg_base = seg->p_vaddr;
6713               break;
6714             }
6715         }
6716     }
6717
6718   /* Second, build the unwind table from the contents of the unwind
6719      section.  */
6720   size = sec->sh_size;
6721   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6722                                       _("unwind table"));
6723   if (!table)
6724     return 0;
6725
6726   unw_ent_size = 16;
6727   nentries = size / unw_ent_size;
6728   size = unw_ent_size * nentries;
6729
6730   tep = aux->table = (struct hppa_unw_table_entry *)
6731       xcmalloc (nentries, sizeof (aux->table[0]));
6732
6733   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6734     {
6735       unsigned int tmp1, tmp2;
6736
6737       tep->start.section = SHN_UNDEF;
6738       tep->end.section   = SHN_UNDEF;
6739
6740       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6741       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6742       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6743       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6744
6745       tep->start.offset += aux->seg_base;
6746       tep->end.offset   += aux->seg_base;
6747
6748       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6749       tep->Millicode = (tmp1 >> 30) & 0x1;
6750       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6751       tep->Region_description = (tmp1 >> 27) & 0x3;
6752       tep->reserved1 = (tmp1 >> 26) & 0x1;
6753       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6754       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6755       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6756       tep->Args_stored = (tmp1 >> 15) & 0x1;
6757       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6758       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6759       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6760       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6761       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6762       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6763       tep->cxx_info = (tmp1 >> 8) & 0x1;
6764       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6765       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6766       tep->reserved2 = (tmp1 >> 5) & 0x1;
6767       tep->Save_SP = (tmp1 >> 4) & 0x1;
6768       tep->Save_RP = (tmp1 >> 3) & 0x1;
6769       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6770       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6771       tep->Cleanup_defined = tmp1 & 0x1;
6772
6773       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6774       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6775       tep->Large_frame = (tmp2 >> 29) & 0x1;
6776       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6777       tep->reserved4 = (tmp2 >> 27) & 0x1;
6778       tep->Total_frame_size = tmp2 & 0x7ffffff;
6779     }
6780   free (table);
6781
6782   /* Third, apply any relocations to the unwind table.  */
6783   for (relsec = section_headers;
6784        relsec < section_headers + elf_header.e_shnum;
6785        ++relsec)
6786     {
6787       if (relsec->sh_type != SHT_RELA
6788           || relsec->sh_info >= elf_header.e_shnum
6789           || section_headers + relsec->sh_info != sec)
6790         continue;
6791
6792       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6793                               & rela, & nrelas))
6794         return 0;
6795
6796       for (rp = rela; rp < rela + nrelas; ++rp)
6797         {
6798           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6799           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6800
6801           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6802           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6803             {
6804               warn (_("Skipping unexpected relocation type %s\n"), relname);
6805               continue;
6806             }
6807
6808           i = rp->r_offset / unw_ent_size;
6809
6810           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6811             {
6812             case 0:
6813               aux->table[i].start.section = sym->st_shndx;
6814               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6815               break;
6816             case 1:
6817               aux->table[i].end.section   = sym->st_shndx;
6818               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6819               break;
6820             default:
6821               break;
6822             }
6823         }
6824
6825       free (rela);
6826     }
6827
6828   aux->table_len = nentries;
6829
6830   return 1;
6831 }
6832
6833 static void
6834 hppa_process_unwind (FILE * file)
6835 {
6836   struct hppa_unw_aux_info aux;
6837   Elf_Internal_Shdr * unwsec = NULL;
6838   Elf_Internal_Shdr * strsec;
6839   Elf_Internal_Shdr * sec;
6840   unsigned long i;
6841
6842   if (string_table == NULL)
6843     return;
6844
6845   memset (& aux, 0, sizeof (aux));
6846
6847   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6848     {
6849       if (sec->sh_type == SHT_SYMTAB
6850           && sec->sh_link < elf_header.e_shnum)
6851         {
6852           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6853
6854           strsec = section_headers + sec->sh_link;
6855           assert (aux.strtab == NULL);
6856           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6857                                           1, strsec->sh_size,
6858                                           _("string table"));
6859           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6860         }
6861       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6862         unwsec = sec;
6863     }
6864
6865   if (!unwsec)
6866     printf (_("\nThere are no unwind sections in this file.\n"));
6867
6868   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6869     {
6870       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6871         {
6872           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
6873                   printable_section_name (sec),
6874                   (unsigned long) sec->sh_offset,
6875                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6876
6877           slurp_hppa_unwind_table (file, &aux, sec);
6878           if (aux.table_len > 0)
6879             dump_hppa_unwind (&aux);
6880
6881           if (aux.table)
6882             free ((char *) aux.table);
6883           aux.table = NULL;
6884         }
6885     }
6886
6887   if (aux.symtab)
6888     free (aux.symtab);
6889   if (aux.strtab)
6890     free ((char *) aux.strtab);
6891 }
6892
6893 struct arm_section
6894 {
6895   unsigned char *      data;            /* The unwind data.  */
6896   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6897   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6898   unsigned long        nrelas;          /* The number of relocations.  */
6899   unsigned int         rel_type;        /* REL or RELA ?  */
6900   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6901 };
6902
6903 struct arm_unw_aux_info
6904 {
6905   FILE *              file;             /* The file containing the unwind sections.  */
6906   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6907   unsigned long       nsyms;            /* Number of symbols.  */
6908   char *              strtab;           /* The file's string table.  */
6909   unsigned long       strtab_size;      /* Size of string table.  */
6910 };
6911
6912 static const char *
6913 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6914                         bfd_vma fn, struct absaddr addr)
6915 {
6916   const char *procname;
6917   bfd_vma sym_offset;
6918
6919   if (addr.section == SHN_UNDEF)
6920     addr.offset = fn;
6921
6922   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6923                            aux->strtab_size, addr, &procname,
6924                            &sym_offset);
6925
6926   print_vma (fn, PREFIX_HEX);
6927
6928   if (procname)
6929     {
6930       fputs (" <", stdout);
6931       fputs (procname, stdout);
6932
6933       if (sym_offset)
6934         printf ("+0x%lx", (unsigned long) sym_offset);
6935       fputc ('>', stdout);
6936     }
6937
6938   return procname;
6939 }
6940
6941 static void
6942 arm_free_section (struct arm_section *arm_sec)
6943 {
6944   if (arm_sec->data != NULL)
6945     free (arm_sec->data);
6946
6947   if (arm_sec->rela != NULL)
6948     free (arm_sec->rela);
6949 }
6950
6951 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6952       cached section and install SEC instead.
6953    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6954       and return its valued in * WORDP, relocating if necessary.
6955    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6956       relocation's offset in ADDR.
6957    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6958       into the string table of the symbol associated with the reloc.  If no
6959       reloc was applied store -1 there.
6960    5) Return TRUE upon success, FALSE otherwise.  */
6961
6962 static bfd_boolean
6963 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6964                          struct arm_section *       arm_sec,
6965                          Elf_Internal_Shdr *        sec,
6966                          bfd_vma                    word_offset,
6967                          unsigned int *             wordp,
6968                          struct absaddr *           addr,
6969                          bfd_vma *                  sym_name)
6970 {
6971   Elf_Internal_Rela *rp;
6972   Elf_Internal_Sym *sym;
6973   const char * relname;
6974   unsigned int word;
6975   bfd_boolean wrapped;
6976
6977   if (sec == NULL || arm_sec == NULL)
6978     return FALSE;
6979
6980   addr->section = SHN_UNDEF;
6981   addr->offset = 0;
6982
6983   if (sym_name != NULL)
6984     *sym_name = (bfd_vma) -1;
6985
6986   /* If necessary, update the section cache.  */
6987   if (sec != arm_sec->sec)
6988     {
6989       Elf_Internal_Shdr *relsec;
6990
6991       arm_free_section (arm_sec);
6992
6993       arm_sec->sec = sec;
6994       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6995                                 sec->sh_size, _("unwind data"));
6996       arm_sec->rela = NULL;
6997       arm_sec->nrelas = 0;
6998
6999       for (relsec = section_headers;
7000            relsec < section_headers + elf_header.e_shnum;
7001            ++relsec)
7002         {
7003           if (relsec->sh_info >= elf_header.e_shnum
7004               || section_headers + relsec->sh_info != sec
7005               /* PR 15745: Check the section type as well.  */
7006               || (relsec->sh_type != SHT_REL
7007                   && relsec->sh_type != SHT_RELA))
7008             continue;
7009
7010           arm_sec->rel_type = relsec->sh_type;
7011           if (relsec->sh_type == SHT_REL)
7012             {
7013               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7014                                      relsec->sh_size,
7015                                      & arm_sec->rela, & arm_sec->nrelas))
7016                 return FALSE;
7017             }
7018           else /* relsec->sh_type == SHT_RELA */
7019             {
7020               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7021                                       relsec->sh_size,
7022                                       & arm_sec->rela, & arm_sec->nrelas))
7023                 return FALSE;
7024             }
7025           break;
7026         }
7027
7028       arm_sec->next_rela = arm_sec->rela;
7029     }
7030
7031   /* If there is no unwind data we can do nothing.  */
7032   if (arm_sec->data == NULL)
7033     return FALSE;
7034
7035   /* If the offset is invalid then fail.  */
7036   if (word_offset > sec->sh_size - 4)
7037     return FALSE;
7038
7039   /* Get the word at the required offset.  */
7040   word = byte_get (arm_sec->data + word_offset, 4);
7041
7042   /* Look through the relocs to find the one that applies to the provided offset.  */
7043   wrapped = FALSE;
7044   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7045     {
7046       bfd_vma prelval, offset;
7047
7048       if (rp->r_offset > word_offset && !wrapped)
7049         {
7050           rp = arm_sec->rela;
7051           wrapped = TRUE;
7052         }
7053       if (rp->r_offset > word_offset)
7054         break;
7055
7056       if (rp->r_offset & 3)
7057         {
7058           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7059                 (unsigned long) rp->r_offset);
7060           continue;
7061         }
7062
7063       if (rp->r_offset < word_offset)
7064         continue;
7065
7066       /* PR 17531: file: 027-161405-0.004  */
7067       if (aux->symtab == NULL)
7068         continue;
7069
7070       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7071
7072       if (arm_sec->rel_type == SHT_REL)
7073         {
7074           offset = word & 0x7fffffff;
7075           if (offset & 0x40000000)
7076             offset |= ~ (bfd_vma) 0x7fffffff;
7077         }
7078       else if (arm_sec->rel_type == SHT_RELA)
7079         offset = rp->r_addend;
7080       else
7081         {
7082           error (_("Unknown section relocation type %d encountered\n"),
7083                  arm_sec->rel_type);
7084           break;
7085         }
7086
7087       offset += sym->st_value;
7088       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7089
7090       /* Check that we are processing the expected reloc type.  */
7091       if (elf_header.e_machine == EM_ARM)
7092         {
7093           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7094
7095           if (streq (relname, "R_ARM_NONE"))
7096               continue;
7097
7098           if (! streq (relname, "R_ARM_PREL31"))
7099             {
7100               warn (_("Skipping unexpected relocation type %s\n"), relname);
7101               continue;
7102             }
7103         }
7104       else if (elf_header.e_machine == EM_TI_C6000)
7105         {
7106           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7107
7108           if (streq (relname, "R_C6000_NONE"))
7109             continue;
7110
7111           if (! streq (relname, "R_C6000_PREL31"))
7112             {
7113               warn (_("Skipping unexpected relocation type %s\n"), relname);
7114               continue;
7115             }
7116
7117           prelval >>= 1;
7118         }
7119       else
7120         {
7121           /* This function currently only supports ARM and TI unwinders.  */
7122           warn (_("Only TI and ARM unwinders are currently supported\n"));
7123           break;
7124         }
7125
7126       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7127       addr->section = sym->st_shndx;
7128       addr->offset = offset;
7129
7130       if (sym_name)
7131         * sym_name = sym->st_name;
7132       break;
7133     }
7134
7135   *wordp = word;
7136   arm_sec->next_rela = rp;
7137
7138   return TRUE;
7139 }
7140
7141 static const char *tic6x_unwind_regnames[16] =
7142 {
7143   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7144   "A14", "A13", "A12", "A11", "A10",
7145   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7146 };
7147
7148 static void
7149 decode_tic6x_unwind_regmask (unsigned int mask)
7150 {
7151   int i;
7152
7153   for (i = 12; mask; mask >>= 1, i--)
7154     {
7155       if (mask & 1)
7156         {
7157           fputs (tic6x_unwind_regnames[i], stdout);
7158           if (mask > 1)
7159             fputs (", ", stdout);
7160         }
7161     }
7162 }
7163
7164 #define ADVANCE                                                 \
7165   if (remaining == 0 && more_words)                             \
7166     {                                                           \
7167       data_offset += 4;                                         \
7168       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7169                                      data_offset, & word, & addr, NULL))        \
7170         return;                                                 \
7171       remaining = 4;                                            \
7172       more_words--;                                             \
7173     }                                                           \
7174
7175 #define GET_OP(OP)                      \
7176   ADVANCE;                              \
7177   if (remaining)                        \
7178     {                                   \
7179       remaining--;                      \
7180       (OP) = word >> 24;                \
7181       word <<= 8;                       \
7182     }                                   \
7183   else                                  \
7184     {                                   \
7185       printf (_("[Truncated opcode]\n"));       \
7186       return;                           \
7187     }                                   \
7188   printf ("0x%02x ", OP)
7189
7190 static void
7191 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7192                             unsigned int word, unsigned int remaining,
7193                             unsigned int more_words,
7194                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7195                             struct arm_section *data_arm_sec)
7196 {
7197   struct absaddr addr;
7198
7199   /* Decode the unwinding instructions.  */
7200   while (1)
7201     {
7202       unsigned int op, op2;
7203
7204       ADVANCE;
7205       if (remaining == 0)
7206         break;
7207       remaining--;
7208       op = word >> 24;
7209       word <<= 8;
7210
7211       printf ("  0x%02x ", op);
7212
7213       if ((op & 0xc0) == 0x00)
7214         {
7215           int offset = ((op & 0x3f) << 2) + 4;
7216
7217           printf ("     vsp = vsp + %d", offset);
7218         }
7219       else if ((op & 0xc0) == 0x40)
7220         {
7221           int offset = ((op & 0x3f) << 2) + 4;
7222
7223           printf ("     vsp = vsp - %d", offset);
7224         }
7225       else if ((op & 0xf0) == 0x80)
7226         {
7227           GET_OP (op2);
7228           if (op == 0x80 && op2 == 0)
7229             printf (_("Refuse to unwind"));
7230           else
7231             {
7232               unsigned int mask = ((op & 0x0f) << 8) | op2;
7233               int first = 1;
7234               int i;
7235
7236               printf ("pop {");
7237               for (i = 0; i < 12; i++)
7238                 if (mask & (1 << i))
7239                   {
7240                     if (first)
7241                       first = 0;
7242                     else
7243                       printf (", ");
7244                     printf ("r%d", 4 + i);
7245                   }
7246               printf ("}");
7247             }
7248         }
7249       else if ((op & 0xf0) == 0x90)
7250         {
7251           if (op == 0x9d || op == 0x9f)
7252             printf (_("     [Reserved]"));
7253           else
7254             printf ("     vsp = r%d", op & 0x0f);
7255         }
7256       else if ((op & 0xf0) == 0xa0)
7257         {
7258           int end = 4 + (op & 0x07);
7259           int first = 1;
7260           int i;
7261
7262           printf ("     pop {");
7263           for (i = 4; i <= end; i++)
7264             {
7265               if (first)
7266                 first = 0;
7267               else
7268                 printf (", ");
7269               printf ("r%d", i);
7270             }
7271           if (op & 0x08)
7272             {
7273               if (!first)
7274                 printf (", ");
7275               printf ("r14");
7276             }
7277           printf ("}");
7278         }
7279       else if (op == 0xb0)
7280         printf (_("     finish"));
7281       else if (op == 0xb1)
7282         {
7283           GET_OP (op2);
7284           if (op2 == 0 || (op2 & 0xf0) != 0)
7285             printf (_("[Spare]"));
7286           else
7287             {
7288               unsigned int mask = op2 & 0x0f;
7289               int first = 1;
7290               int i;
7291
7292               printf ("pop {");
7293               for (i = 0; i < 12; i++)
7294                 if (mask & (1 << i))
7295                   {
7296                     if (first)
7297                       first = 0;
7298                     else
7299                       printf (", ");
7300                     printf ("r%d", i);
7301                   }
7302               printf ("}");
7303             }
7304         }
7305       else if (op == 0xb2)
7306         {
7307           unsigned char buf[9];
7308           unsigned int i, len;
7309           unsigned long offset;
7310
7311           for (i = 0; i < sizeof (buf); i++)
7312             {
7313               GET_OP (buf[i]);
7314               if ((buf[i] & 0x80) == 0)
7315                 break;
7316             }
7317           assert (i < sizeof (buf));
7318           offset = read_uleb128 (buf, &len, buf + i + 1);
7319           assert (len == i + 1);
7320           offset = offset * 4 + 0x204;
7321           printf ("vsp = vsp + %ld", offset);
7322         }
7323       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7324         {
7325           unsigned int first, last;
7326
7327           GET_OP (op2);
7328           first = op2 >> 4;
7329           last = op2 & 0x0f;
7330           if (op == 0xc8)
7331             first = first + 16;
7332           printf ("pop {D%d", first);
7333           if (last)
7334             printf ("-D%d", first + last);
7335           printf ("}");
7336         }
7337       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7338         {
7339           unsigned int count = op & 0x07;
7340
7341           printf ("pop {D8");
7342           if (count)
7343             printf ("-D%d", 8 + count);
7344           printf ("}");
7345         }
7346       else if (op >= 0xc0 && op <= 0xc5)
7347         {
7348           unsigned int count = op & 0x07;
7349
7350           printf ("     pop {wR10");
7351           if (count)
7352             printf ("-wR%d", 10 + count);
7353           printf ("}");
7354         }
7355       else if (op == 0xc6)
7356         {
7357           unsigned int first, last;
7358
7359           GET_OP (op2);
7360           first = op2 >> 4;
7361           last = op2 & 0x0f;
7362           printf ("pop {wR%d", first);
7363           if (last)
7364             printf ("-wR%d", first + last);
7365           printf ("}");
7366         }
7367       else if (op == 0xc7)
7368         {
7369           GET_OP (op2);
7370           if (op2 == 0 || (op2 & 0xf0) != 0)
7371             printf (_("[Spare]"));
7372           else
7373             {
7374               unsigned int mask = op2 & 0x0f;
7375               int first = 1;
7376               int i;
7377
7378               printf ("pop {");
7379               for (i = 0; i < 4; i++)
7380                 if (mask & (1 << i))
7381                   {
7382                     if (first)
7383                       first = 0;
7384                     else
7385                       printf (", ");
7386                     printf ("wCGR%d", i);
7387                   }
7388               printf ("}");
7389             }
7390         }
7391       else
7392         printf (_("     [unsupported opcode]"));
7393       printf ("\n");
7394     }
7395 }
7396
7397 static void
7398 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7399                             unsigned int word, unsigned int remaining,
7400                             unsigned int more_words,
7401                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7402                             struct arm_section *data_arm_sec)
7403 {
7404   struct absaddr addr;
7405
7406   /* Decode the unwinding instructions.  */
7407   while (1)
7408     {
7409       unsigned int op, op2;
7410
7411       ADVANCE;
7412       if (remaining == 0)
7413         break;
7414       remaining--;
7415       op = word >> 24;
7416       word <<= 8;
7417
7418       printf ("  0x%02x ", op);
7419
7420       if ((op & 0xc0) == 0x00)
7421         {
7422           int offset = ((op & 0x3f) << 3) + 8;
7423           printf ("     sp = sp + %d", offset);
7424         }
7425       else if ((op & 0xc0) == 0x80)
7426         {
7427           GET_OP (op2);
7428           if (op == 0x80 && op2 == 0)
7429             printf (_("Refuse to unwind"));
7430           else
7431             {
7432               unsigned int mask = ((op & 0x1f) << 8) | op2;
7433               if (op & 0x20)
7434                 printf ("pop compact {");
7435               else
7436                 printf ("pop {");
7437
7438               decode_tic6x_unwind_regmask (mask);
7439               printf("}");
7440             }
7441         }
7442       else if ((op & 0xf0) == 0xc0)
7443         {
7444           unsigned int reg;
7445           unsigned int nregs;
7446           unsigned int i;
7447           const char *name;
7448           struct
7449           {
7450               unsigned int offset;
7451               unsigned int reg;
7452           } regpos[16];
7453
7454           /* Scan entire instruction first so that GET_OP output is not
7455              interleaved with disassembly.  */
7456           nregs = 0;
7457           for (i = 0; nregs < (op & 0xf); i++)
7458             {
7459               GET_OP (op2);
7460               reg = op2 >> 4;
7461               if (reg != 0xf)
7462                 {
7463                   regpos[nregs].offset = i * 2;
7464                   regpos[nregs].reg = reg;
7465                   nregs++;
7466                 }
7467
7468               reg = op2 & 0xf;
7469               if (reg != 0xf)
7470                 {
7471                   regpos[nregs].offset = i * 2 + 1;
7472                   regpos[nregs].reg = reg;
7473                   nregs++;
7474                 }
7475             }
7476
7477           printf (_("pop frame {"));
7478           reg = nregs - 1;
7479           for (i = i * 2; i > 0; i--)
7480             {
7481               if (regpos[reg].offset == i - 1)
7482                 {
7483                   name = tic6x_unwind_regnames[regpos[reg].reg];
7484                   if (reg > 0)
7485                     reg--;
7486                 }
7487               else
7488                 name = _("[pad]");
7489
7490               fputs (name, stdout);
7491               if (i > 1)
7492                 printf (", ");
7493             }
7494
7495           printf ("}");
7496         }
7497       else if (op == 0xd0)
7498         printf ("     MOV FP, SP");
7499       else if (op == 0xd1)
7500         printf ("     __c6xabi_pop_rts");
7501       else if (op == 0xd2)
7502         {
7503           unsigned char buf[9];
7504           unsigned int i, len;
7505           unsigned long offset;
7506
7507           for (i = 0; i < sizeof (buf); i++)
7508             {
7509               GET_OP (buf[i]);
7510               if ((buf[i] & 0x80) == 0)
7511                 break;
7512             }
7513           assert (i < sizeof (buf));
7514           offset = read_uleb128 (buf, &len, buf + i + 1);
7515           assert (len == i + 1);
7516           offset = offset * 8 + 0x408;
7517           printf (_("sp = sp + %ld"), offset);
7518         }
7519       else if ((op & 0xf0) == 0xe0)
7520         {
7521           if ((op & 0x0f) == 7)
7522             printf ("     RETURN");
7523           else
7524             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7525         }
7526       else
7527         {
7528           printf (_("     [unsupported opcode]"));
7529         }
7530       putchar ('\n');
7531     }
7532 }
7533
7534 static bfd_vma
7535 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7536 {
7537   bfd_vma offset;
7538
7539   offset = word & 0x7fffffff;
7540   if (offset & 0x40000000)
7541     offset |= ~ (bfd_vma) 0x7fffffff;
7542
7543   if (elf_header.e_machine == EM_TI_C6000)
7544     offset <<= 1;
7545
7546   return offset + where;
7547 }
7548
7549 static void
7550 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7551                    unsigned int               word,
7552                    unsigned int               remaining,
7553                    bfd_vma                    data_offset,
7554                    Elf_Internal_Shdr *        data_sec,
7555                    struct arm_section *       data_arm_sec)
7556 {
7557   int per_index;
7558   unsigned int more_words = 0;
7559   struct absaddr addr;
7560   bfd_vma sym_name = (bfd_vma) -1;
7561
7562   if (remaining == 0)
7563     {
7564       /* Fetch the first word.
7565          Note - when decoding an object file the address extracted
7566          here will always be 0.  So we also pass in the sym_name
7567          parameter so that we can find the symbol associated with
7568          the personality routine.  */
7569       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7570                                      & word, & addr, & sym_name))
7571         return;
7572
7573       remaining = 4;
7574     }
7575
7576   if ((word & 0x80000000) == 0)
7577     {
7578       /* Expand prel31 for personality routine.  */
7579       bfd_vma fn;
7580       const char *procname;
7581
7582       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7583       printf (_("  Personality routine: "));
7584       if (fn == 0
7585           && addr.section == SHN_UNDEF && addr.offset == 0
7586           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7587         {
7588           procname = aux->strtab + sym_name;
7589           print_vma (fn, PREFIX_HEX);
7590           if (procname)
7591             {
7592               fputs (" <", stdout);
7593               fputs (procname, stdout);
7594               fputc ('>', stdout);
7595             }
7596         }
7597       else
7598         procname = arm_print_vma_and_name (aux, fn, addr);
7599       fputc ('\n', stdout);
7600
7601       /* The GCC personality routines use the standard compact
7602          encoding, starting with one byte giving the number of
7603          words.  */
7604       if (procname != NULL
7605           && (const_strneq (procname, "__gcc_personality_v0")
7606               || const_strneq (procname, "__gxx_personality_v0")
7607               || const_strneq (procname, "__gcj_personality_v0")
7608               || const_strneq (procname, "__gnu_objc_personality_v0")))
7609         {
7610           remaining = 0;
7611           more_words = 1;
7612           ADVANCE;
7613           if (!remaining)
7614             {
7615               printf (_("  [Truncated data]\n"));
7616               return;
7617             }
7618           more_words = word >> 24;
7619           word <<= 8;
7620           remaining--;
7621           per_index = -1;
7622         }
7623       else
7624         return;
7625     }
7626   else
7627     {
7628       /* ARM EHABI Section 6.3:
7629
7630          An exception-handling table entry for the compact model looks like:
7631
7632            31 30-28 27-24 23-0
7633            -- ----- ----- ----
7634             1   0   index Data for personalityRoutine[index]    */
7635
7636       if (elf_header.e_machine == EM_ARM
7637           && (word & 0x70000000))
7638         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7639
7640       per_index = (word >> 24) & 0x7f;
7641       printf (_("  Compact model index: %d\n"), per_index);
7642       if (per_index == 0)
7643         {
7644           more_words = 0;
7645           word <<= 8;
7646           remaining--;
7647         }
7648       else if (per_index < 3)
7649         {
7650           more_words = (word >> 16) & 0xff;
7651           word <<= 16;
7652           remaining -= 2;
7653         }
7654     }
7655
7656   switch (elf_header.e_machine)
7657     {
7658     case EM_ARM:
7659       if (per_index < 3)
7660         {
7661           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7662                                       data_offset, data_sec, data_arm_sec);
7663         }
7664       else
7665         {
7666           warn (_("Unknown ARM compact model index encountered\n"));
7667           printf (_("  [reserved]\n"));
7668         }
7669       break;
7670
7671     case EM_TI_C6000:
7672       if (per_index < 3)
7673         {
7674           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7675                                         data_offset, data_sec, data_arm_sec);
7676         }
7677       else if (per_index < 5)
7678         {
7679           if (((word >> 17) & 0x7f) == 0x7f)
7680             printf (_("  Restore stack from frame pointer\n"));
7681           else
7682             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7683           printf (_("  Registers restored: "));
7684           if (per_index == 4)
7685             printf (" (compact) ");
7686           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7687           putchar ('\n');
7688           printf (_("  Return register: %s\n"),
7689                   tic6x_unwind_regnames[word & 0xf]);
7690         }
7691       else
7692         printf (_("  [reserved (%d)]\n"), per_index);
7693       break;
7694
7695     default:
7696       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7697              elf_header.e_machine);
7698     }
7699
7700   /* Decode the descriptors.  Not implemented.  */
7701 }
7702
7703 static void
7704 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7705 {
7706   struct arm_section exidx_arm_sec, extab_arm_sec;
7707   unsigned int i, exidx_len;
7708
7709   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7710   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7711   exidx_len = exidx_sec->sh_size / 8;
7712
7713   for (i = 0; i < exidx_len; i++)
7714     {
7715       unsigned int exidx_fn, exidx_entry;
7716       struct absaddr fn_addr, entry_addr;
7717       bfd_vma fn;
7718
7719       fputc ('\n', stdout);
7720
7721       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7722                                      8 * i, & exidx_fn, & fn_addr, NULL)
7723           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7724                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7725         {
7726           arm_free_section (& exidx_arm_sec);
7727           arm_free_section (& extab_arm_sec);
7728           return;
7729         }
7730
7731       /* ARM EHABI, Section 5:
7732          An index table entry consists of 2 words.
7733          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7734       if (exidx_fn & 0x80000000)
7735         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7736
7737       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7738
7739       arm_print_vma_and_name (aux, fn, fn_addr);
7740       fputs (": ", stdout);
7741
7742       if (exidx_entry == 1)
7743         {
7744           print_vma (exidx_entry, PREFIX_HEX);
7745           fputs (" [cantunwind]\n", stdout);
7746         }
7747       else if (exidx_entry & 0x80000000)
7748         {
7749           print_vma (exidx_entry, PREFIX_HEX);
7750           fputc ('\n', stdout);
7751           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7752         }
7753       else
7754         {
7755           bfd_vma table, table_offset = 0;
7756           Elf_Internal_Shdr *table_sec;
7757
7758           fputs ("@", stdout);
7759           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7760           print_vma (table, PREFIX_HEX);
7761           printf ("\n");
7762
7763           /* Locate the matching .ARM.extab.  */
7764           if (entry_addr.section != SHN_UNDEF
7765               && entry_addr.section < elf_header.e_shnum)
7766             {
7767               table_sec = section_headers + entry_addr.section;
7768               table_offset = entry_addr.offset;
7769             }
7770           else
7771             {
7772               table_sec = find_section_by_address (table);
7773               if (table_sec != NULL)
7774                 table_offset = table - table_sec->sh_addr;
7775             }
7776           if (table_sec == NULL)
7777             {
7778               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7779                     (unsigned long) table);
7780               continue;
7781             }
7782           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7783                              &extab_arm_sec);
7784         }
7785     }
7786
7787   printf ("\n");
7788
7789   arm_free_section (&exidx_arm_sec);
7790   arm_free_section (&extab_arm_sec);
7791 }
7792
7793 /* Used for both ARM and C6X unwinding tables.  */
7794
7795 static void
7796 arm_process_unwind (FILE *file)
7797 {
7798   struct arm_unw_aux_info aux;
7799   Elf_Internal_Shdr *unwsec = NULL;
7800   Elf_Internal_Shdr *strsec;
7801   Elf_Internal_Shdr *sec;
7802   unsigned long i;
7803   unsigned int sec_type;
7804
7805   switch (elf_header.e_machine)
7806     {
7807     case EM_ARM:
7808       sec_type = SHT_ARM_EXIDX;
7809       break;
7810
7811     case EM_TI_C6000:
7812       sec_type = SHT_C6000_UNWIND;
7813       break;
7814
7815     default:
7816       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
7817              elf_header.e_machine);
7818       return;
7819     }
7820
7821   if (string_table == NULL)
7822     return;
7823
7824   memset (& aux, 0, sizeof (aux));
7825   aux.file = file;
7826
7827   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7828     {
7829       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7830         {
7831           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7832
7833           strsec = section_headers + sec->sh_link;
7834
7835           /* PR binutils/17531 file: 011-12666-0.004.  */
7836           if (aux.strtab != NULL)
7837             {
7838               warn (_("Multiple string tables found in file.\n"));
7839               free (aux.strtab);
7840             }
7841           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7842                                  1, strsec->sh_size, _("string table"));
7843           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7844         }
7845       else if (sec->sh_type == sec_type)
7846         unwsec = sec;
7847     }
7848
7849   if (unwsec == NULL)
7850     printf (_("\nThere are no unwind sections in this file.\n"));
7851   else
7852     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7853       {
7854         if (sec->sh_type == sec_type)
7855           {
7856             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7857                     printable_section_name (sec),
7858                     (unsigned long) sec->sh_offset,
7859                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7860
7861             dump_arm_unwind (&aux, sec);
7862           }
7863       }
7864
7865   if (aux.symtab)
7866     free (aux.symtab);
7867   if (aux.strtab)
7868     free ((char *) aux.strtab);
7869 }
7870
7871 static void
7872 process_unwind (FILE * file)
7873 {
7874   struct unwind_handler
7875   {
7876     int machtype;
7877     void (* handler)(FILE *);
7878   } handlers[] =
7879   {
7880     { EM_ARM, arm_process_unwind },
7881     { EM_IA_64, ia64_process_unwind },
7882     { EM_PARISC, hppa_process_unwind },
7883     { EM_TI_C6000, arm_process_unwind },
7884     { 0, 0 }
7885   };
7886   int i;
7887
7888   if (!do_unwind)
7889     return;
7890
7891   for (i = 0; handlers[i].handler != NULL; i++)
7892     if (elf_header.e_machine == handlers[i].machtype)
7893       {
7894         handlers[i].handler (file);
7895         return;
7896       }
7897
7898   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7899           get_machine_name (elf_header.e_machine));
7900 }
7901
7902 static void
7903 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7904 {
7905   switch (entry->d_tag)
7906     {
7907     case DT_MIPS_FLAGS:
7908       if (entry->d_un.d_val == 0)
7909         printf (_("NONE"));
7910       else
7911         {
7912           static const char * opts[] =
7913           {
7914             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7915             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7916             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7917             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7918             "RLD_ORDER_SAFE"
7919           };
7920           unsigned int cnt;
7921           int first = 1;
7922
7923           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7924             if (entry->d_un.d_val & (1 << cnt))
7925               {
7926                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7927                 first = 0;
7928               }
7929         }
7930       break;
7931
7932     case DT_MIPS_IVERSION:
7933       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7934         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7935       else
7936         {
7937           char buf[40];
7938           sprintf_vma (buf, entry->d_un.d_ptr);
7939           /* Note: coded this way so that there is a single string for translation.  */
7940           printf (_("<corrupt: %s>"), buf);
7941         }
7942       break;
7943
7944     case DT_MIPS_TIME_STAMP:
7945       {
7946         char timebuf[20];
7947         struct tm * tmp;
7948
7949         time_t atime = entry->d_un.d_val;
7950         tmp = gmtime (&atime);
7951         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7952                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7953                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7954         printf (_("Time Stamp: %s"), timebuf);
7955       }
7956       break;
7957
7958     case DT_MIPS_RLD_VERSION:
7959     case DT_MIPS_LOCAL_GOTNO:
7960     case DT_MIPS_CONFLICTNO:
7961     case DT_MIPS_LIBLISTNO:
7962     case DT_MIPS_SYMTABNO:
7963     case DT_MIPS_UNREFEXTNO:
7964     case DT_MIPS_HIPAGENO:
7965     case DT_MIPS_DELTA_CLASS_NO:
7966     case DT_MIPS_DELTA_INSTANCE_NO:
7967     case DT_MIPS_DELTA_RELOC_NO:
7968     case DT_MIPS_DELTA_SYM_NO:
7969     case DT_MIPS_DELTA_CLASSSYM_NO:
7970     case DT_MIPS_COMPACT_SIZE:
7971       print_vma (entry->d_un.d_ptr, DEC);
7972       break;
7973
7974     default:
7975       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7976     }
7977     putchar ('\n');
7978 }
7979
7980 static void
7981 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7982 {
7983   switch (entry->d_tag)
7984     {
7985     case DT_HP_DLD_FLAGS:
7986       {
7987         static struct
7988         {
7989           long int bit;
7990           const char * str;
7991         }
7992         flags[] =
7993         {
7994           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7995           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7996           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7997           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7998           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7999           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8000           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8001           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8002           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8003           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8004           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8005           { DT_HP_GST, "HP_GST" },
8006           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8007           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8008           { DT_HP_NODELETE, "HP_NODELETE" },
8009           { DT_HP_GROUP, "HP_GROUP" },
8010           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8011         };
8012         int first = 1;
8013         size_t cnt;
8014         bfd_vma val = entry->d_un.d_val;
8015
8016         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8017           if (val & flags[cnt].bit)
8018             {
8019               if (! first)
8020                 putchar (' ');
8021               fputs (flags[cnt].str, stdout);
8022               first = 0;
8023               val ^= flags[cnt].bit;
8024             }
8025
8026         if (val != 0 || first)
8027           {
8028             if (! first)
8029               putchar (' ');
8030             print_vma (val, HEX);
8031           }
8032       }
8033       break;
8034
8035     default:
8036       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8037       break;
8038     }
8039   putchar ('\n');
8040 }
8041
8042 #ifdef BFD64
8043
8044 /* VMS vs Unix time offset and factor.  */
8045
8046 #define VMS_EPOCH_OFFSET 35067168000000000LL
8047 #define VMS_GRANULARITY_FACTOR 10000000
8048
8049 /* Display a VMS time in a human readable format.  */
8050
8051 static void
8052 print_vms_time (bfd_int64_t vmstime)
8053 {
8054   struct tm *tm;
8055   time_t unxtime;
8056
8057   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8058   tm = gmtime (&unxtime);
8059   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8060           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8061           tm->tm_hour, tm->tm_min, tm->tm_sec);
8062 }
8063 #endif /* BFD64 */
8064
8065 static void
8066 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8067 {
8068   switch (entry->d_tag)
8069     {
8070     case DT_IA_64_PLT_RESERVE:
8071       /* First 3 slots reserved.  */
8072       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8073       printf (" -- ");
8074       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8075       break;
8076
8077     case DT_IA_64_VMS_LINKTIME:
8078 #ifdef BFD64
8079       print_vms_time (entry->d_un.d_val);
8080 #endif
8081       break;
8082
8083     case DT_IA_64_VMS_LNKFLAGS:
8084       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8085       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8086         printf (" CALL_DEBUG");
8087       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8088         printf (" NOP0BUFS");
8089       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8090         printf (" P0IMAGE");
8091       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8092         printf (" MKTHREADS");
8093       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8094         printf (" UPCALLS");
8095       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8096         printf (" IMGSTA");
8097       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8098         printf (" INITIALIZE");
8099       if (entry->d_un.d_val & VMS_LF_MAIN)
8100         printf (" MAIN");
8101       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8102         printf (" EXE_INIT");
8103       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8104         printf (" TBK_IN_IMG");
8105       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8106         printf (" DBG_IN_IMG");
8107       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8108         printf (" TBK_IN_DSF");
8109       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8110         printf (" DBG_IN_DSF");
8111       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8112         printf (" SIGNATURES");
8113       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8114         printf (" REL_SEG_OFF");
8115       break;
8116
8117     default:
8118       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8119       break;
8120     }
8121   putchar ('\n');
8122 }
8123
8124 static int
8125 get_32bit_dynamic_section (FILE * file)
8126 {
8127   Elf32_External_Dyn * edyn;
8128   Elf32_External_Dyn * ext;
8129   Elf_Internal_Dyn * entry;
8130
8131   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8132                                           dynamic_size, _("dynamic section"));
8133   if (!edyn)
8134     return 0;
8135
8136 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8137    might not have the luxury of section headers.  Look for the DT_NULL
8138    terminator to determine the number of entries.  */
8139   for (ext = edyn, dynamic_nent = 0;
8140        (char *) ext < (char *) edyn + dynamic_size;
8141        ext++)
8142     {
8143       dynamic_nent++;
8144       if (BYTE_GET (ext->d_tag) == DT_NULL)
8145         break;
8146     }
8147
8148   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8149                                                   sizeof (* entry));
8150   if (dynamic_section == NULL)
8151     {
8152       error (_("Out of memory\n"));
8153       free (edyn);
8154       return 0;
8155     }
8156
8157   for (ext = edyn, entry = dynamic_section;
8158        entry < dynamic_section + dynamic_nent;
8159        ext++, entry++)
8160     {
8161       entry->d_tag      = BYTE_GET (ext->d_tag);
8162       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8163     }
8164
8165   free (edyn);
8166
8167   return 1;
8168 }
8169
8170 static int
8171 get_64bit_dynamic_section (FILE * file)
8172 {
8173   Elf64_External_Dyn * edyn;
8174   Elf64_External_Dyn * ext;
8175   Elf_Internal_Dyn * entry;
8176
8177   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8178                                           dynamic_size, _("dynamic section"));
8179   if (!edyn)
8180     return 0;
8181
8182 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8183    might not have the luxury of section headers.  Look for the DT_NULL
8184    terminator to determine the number of entries.  */
8185   for (ext = edyn, dynamic_nent = 0;
8186        (char *) ext < (char *) edyn + dynamic_size;
8187        ext++)
8188     {
8189       dynamic_nent++;
8190       if (BYTE_GET (ext->d_tag) == DT_NULL)
8191         break;
8192     }
8193
8194   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8195                                                   sizeof (* entry));
8196   if (dynamic_section == NULL)
8197     {
8198       error (_("Out of memory\n"));
8199       free (edyn);
8200       return 0;
8201     }
8202
8203   for (ext = edyn, entry = dynamic_section;
8204        entry < dynamic_section + dynamic_nent;
8205        ext++, entry++)
8206     {
8207       entry->d_tag      = BYTE_GET (ext->d_tag);
8208       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8209     }
8210
8211   free (edyn);
8212
8213   return 1;
8214 }
8215
8216 static void
8217 print_dynamic_flags (bfd_vma flags)
8218 {
8219   int first = 1;
8220
8221   while (flags)
8222     {
8223       bfd_vma flag;
8224
8225       flag = flags & - flags;
8226       flags &= ~ flag;
8227
8228       if (first)
8229         first = 0;
8230       else
8231         putc (' ', stdout);
8232
8233       switch (flag)
8234         {
8235         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8236         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8237         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8238         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8239         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8240         default:                fputs (_("unknown"), stdout); break;
8241         }
8242     }
8243   puts ("");
8244 }
8245
8246 /* Parse and display the contents of the dynamic section.  */
8247
8248 static int
8249 process_dynamic_section (FILE * file)
8250 {
8251   Elf_Internal_Dyn * entry;
8252
8253   if (dynamic_size == 0)
8254     {
8255       if (do_dynamic)
8256         printf (_("\nThere is no dynamic section in this file.\n"));
8257
8258       return 1;
8259     }
8260
8261   if (is_32bit_elf)
8262     {
8263       if (! get_32bit_dynamic_section (file))
8264         return 0;
8265     }
8266   else if (! get_64bit_dynamic_section (file))
8267     return 0;
8268
8269   /* Find the appropriate symbol table.  */
8270   if (dynamic_symbols == NULL)
8271     {
8272       for (entry = dynamic_section;
8273            entry < dynamic_section + dynamic_nent;
8274            ++entry)
8275         {
8276           Elf_Internal_Shdr section;
8277
8278           if (entry->d_tag != DT_SYMTAB)
8279             continue;
8280
8281           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8282
8283           /* Since we do not know how big the symbol table is,
8284              we default to reading in the entire file (!) and
8285              processing that.  This is overkill, I know, but it
8286              should work.  */
8287           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8288
8289           if (archive_file_offset != 0)
8290             section.sh_size = archive_file_size - section.sh_offset;
8291           else
8292             {
8293               if (fseek (file, 0, SEEK_END))
8294                 error (_("Unable to seek to end of file!\n"));
8295
8296               section.sh_size = ftell (file) - section.sh_offset;
8297             }
8298
8299           if (is_32bit_elf)
8300             section.sh_entsize = sizeof (Elf32_External_Sym);
8301           else
8302             section.sh_entsize = sizeof (Elf64_External_Sym);
8303
8304           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8305           if (num_dynamic_syms < 1)
8306             {
8307               error (_("Unable to determine the number of symbols to load\n"));
8308               continue;
8309             }
8310         }
8311     }
8312
8313   /* Similarly find a string table.  */
8314   if (dynamic_strings == NULL)
8315     {
8316       for (entry = dynamic_section;
8317            entry < dynamic_section + dynamic_nent;
8318            ++entry)
8319         {
8320           unsigned long offset;
8321           long str_tab_len;
8322
8323           if (entry->d_tag != DT_STRTAB)
8324             continue;
8325
8326           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8327
8328           /* Since we do not know how big the string table is,
8329              we default to reading in the entire file (!) and
8330              processing that.  This is overkill, I know, but it
8331              should work.  */
8332
8333           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8334
8335           if (archive_file_offset != 0)
8336             str_tab_len = archive_file_size - offset;
8337           else
8338             {
8339               if (fseek (file, 0, SEEK_END))
8340                 error (_("Unable to seek to end of file\n"));
8341               str_tab_len = ftell (file) - offset;
8342             }
8343
8344           if (str_tab_len < 1)
8345             {
8346               error
8347                 (_("Unable to determine the length of the dynamic string table\n"));
8348               continue;
8349             }
8350
8351           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8352                                                str_tab_len,
8353                                                _("dynamic string table"));
8354           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8355           break;
8356         }
8357     }
8358
8359   /* And find the syminfo section if available.  */
8360   if (dynamic_syminfo == NULL)
8361     {
8362       unsigned long syminsz = 0;
8363
8364       for (entry = dynamic_section;
8365            entry < dynamic_section + dynamic_nent;
8366            ++entry)
8367         {
8368           if (entry->d_tag == DT_SYMINENT)
8369             {
8370               /* Note: these braces are necessary to avoid a syntax
8371                  error from the SunOS4 C compiler.  */
8372               /* PR binutils/17531: A corrupt file can trigger this test.
8373                  So do not use an assert, instead generate an error message.  */
8374               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8375                 error (_("Bad value (%d) for SYMINENT entry"),
8376                        (int) entry->d_un.d_val);
8377             }
8378           else if (entry->d_tag == DT_SYMINSZ)
8379             syminsz = entry->d_un.d_val;
8380           else if (entry->d_tag == DT_SYMINFO)
8381             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8382                                                       syminsz);
8383         }
8384
8385       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8386         {
8387           Elf_External_Syminfo * extsyminfo;
8388           Elf_External_Syminfo * extsym;
8389           Elf_Internal_Syminfo * syminfo;
8390
8391           /* There is a syminfo section.  Read the data.  */
8392           extsyminfo = (Elf_External_Syminfo *)
8393               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8394                         _("symbol information"));
8395           if (!extsyminfo)
8396             return 0;
8397
8398           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8399           if (dynamic_syminfo == NULL)
8400             {
8401               error (_("Out of memory\n"));
8402               return 0;
8403             }
8404
8405           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8406           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8407                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8408                ++syminfo, ++extsym)
8409             {
8410               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8411               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8412             }
8413
8414           free (extsyminfo);
8415         }
8416     }
8417
8418   if (do_dynamic && dynamic_addr)
8419     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8420             dynamic_addr, dynamic_nent);
8421   if (do_dynamic)
8422     printf (_("  Tag        Type                         Name/Value\n"));
8423
8424   for (entry = dynamic_section;
8425        entry < dynamic_section + dynamic_nent;
8426        entry++)
8427     {
8428       if (do_dynamic)
8429         {
8430           const char * dtype;
8431
8432           putchar (' ');
8433           print_vma (entry->d_tag, FULL_HEX);
8434           dtype = get_dynamic_type (entry->d_tag);
8435           printf (" (%s)%*s", dtype,
8436                   ((is_32bit_elf ? 27 : 19)
8437                    - (int) strlen (dtype)),
8438                   " ");
8439         }
8440
8441       switch (entry->d_tag)
8442         {
8443         case DT_FLAGS:
8444           if (do_dynamic)
8445             print_dynamic_flags (entry->d_un.d_val);
8446           break;
8447
8448         case DT_AUXILIARY:
8449         case DT_FILTER:
8450         case DT_CONFIG:
8451         case DT_DEPAUDIT:
8452         case DT_AUDIT:
8453           if (do_dynamic)
8454             {
8455               switch (entry->d_tag)
8456                 {
8457                 case DT_AUXILIARY:
8458                   printf (_("Auxiliary library"));
8459                   break;
8460
8461                 case DT_FILTER:
8462                   printf (_("Filter library"));
8463                   break;
8464
8465                 case DT_CONFIG:
8466                   printf (_("Configuration file"));
8467                   break;
8468
8469                 case DT_DEPAUDIT:
8470                   printf (_("Dependency audit library"));
8471                   break;
8472
8473                 case DT_AUDIT:
8474                   printf (_("Audit library"));
8475                   break;
8476                 }
8477
8478               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8479                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8480               else
8481                 {
8482                   printf (": ");
8483                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8484                   putchar ('\n');
8485                 }
8486             }
8487           break;
8488
8489         case DT_FEATURE:
8490           if (do_dynamic)
8491             {
8492               printf (_("Flags:"));
8493
8494               if (entry->d_un.d_val == 0)
8495                 printf (_(" None\n"));
8496               else
8497                 {
8498                   unsigned long int val = entry->d_un.d_val;
8499
8500                   if (val & DTF_1_PARINIT)
8501                     {
8502                       printf (" PARINIT");
8503                       val ^= DTF_1_PARINIT;
8504                     }
8505                   if (val & DTF_1_CONFEXP)
8506                     {
8507                       printf (" CONFEXP");
8508                       val ^= DTF_1_CONFEXP;
8509                     }
8510                   if (val != 0)
8511                     printf (" %lx", val);
8512                   puts ("");
8513                 }
8514             }
8515           break;
8516
8517         case DT_POSFLAG_1:
8518           if (do_dynamic)
8519             {
8520               printf (_("Flags:"));
8521
8522               if (entry->d_un.d_val == 0)
8523                 printf (_(" None\n"));
8524               else
8525                 {
8526                   unsigned long int val = entry->d_un.d_val;
8527
8528                   if (val & DF_P1_LAZYLOAD)
8529                     {
8530                       printf (" LAZYLOAD");
8531                       val ^= DF_P1_LAZYLOAD;
8532                     }
8533                   if (val & DF_P1_GROUPPERM)
8534                     {
8535                       printf (" GROUPPERM");
8536                       val ^= DF_P1_GROUPPERM;
8537                     }
8538                   if (val != 0)
8539                     printf (" %lx", val);
8540                   puts ("");
8541                 }
8542             }
8543           break;
8544
8545         case DT_FLAGS_1:
8546           if (do_dynamic)
8547             {
8548               printf (_("Flags:"));
8549               if (entry->d_un.d_val == 0)
8550                 printf (_(" None\n"));
8551               else
8552                 {
8553                   unsigned long int val = entry->d_un.d_val;
8554
8555                   if (val & DF_1_NOW)
8556                     {
8557                       printf (" NOW");
8558                       val ^= DF_1_NOW;
8559                     }
8560                   if (val & DF_1_GLOBAL)
8561                     {
8562                       printf (" GLOBAL");
8563                       val ^= DF_1_GLOBAL;
8564                     }
8565                   if (val & DF_1_GROUP)
8566                     {
8567                       printf (" GROUP");
8568                       val ^= DF_1_GROUP;
8569                     }
8570                   if (val & DF_1_NODELETE)
8571                     {
8572                       printf (" NODELETE");
8573                       val ^= DF_1_NODELETE;
8574                     }
8575                   if (val & DF_1_LOADFLTR)
8576                     {
8577                       printf (" LOADFLTR");
8578                       val ^= DF_1_LOADFLTR;
8579                     }
8580                   if (val & DF_1_INITFIRST)
8581                     {
8582                       printf (" INITFIRST");
8583                       val ^= DF_1_INITFIRST;
8584                     }
8585                   if (val & DF_1_NOOPEN)
8586                     {
8587                       printf (" NOOPEN");
8588                       val ^= DF_1_NOOPEN;
8589                     }
8590                   if (val & DF_1_ORIGIN)
8591                     {
8592                       printf (" ORIGIN");
8593                       val ^= DF_1_ORIGIN;
8594                     }
8595                   if (val & DF_1_DIRECT)
8596                     {
8597                       printf (" DIRECT");
8598                       val ^= DF_1_DIRECT;
8599                     }
8600                   if (val & DF_1_TRANS)
8601                     {
8602                       printf (" TRANS");
8603                       val ^= DF_1_TRANS;
8604                     }
8605                   if (val & DF_1_INTERPOSE)
8606                     {
8607                       printf (" INTERPOSE");
8608                       val ^= DF_1_INTERPOSE;
8609                     }
8610                   if (val & DF_1_NODEFLIB)
8611                     {
8612                       printf (" NODEFLIB");
8613                       val ^= DF_1_NODEFLIB;
8614                     }
8615                   if (val & DF_1_NODUMP)
8616                     {
8617                       printf (" NODUMP");
8618                       val ^= DF_1_NODUMP;
8619                     }
8620                   if (val & DF_1_CONFALT)
8621                     {
8622                       printf (" CONFALT");
8623                       val ^= DF_1_CONFALT;
8624                     }
8625                   if (val & DF_1_ENDFILTEE)
8626                     {
8627                       printf (" ENDFILTEE");
8628                       val ^= DF_1_ENDFILTEE;
8629                     }
8630                   if (val & DF_1_DISPRELDNE)
8631                     {
8632                       printf (" DISPRELDNE");
8633                       val ^= DF_1_DISPRELDNE;
8634                     }
8635                   if (val & DF_1_DISPRELPND)
8636                     {
8637                       printf (" DISPRELPND");
8638                       val ^= DF_1_DISPRELPND;
8639                     }
8640                   if (val & DF_1_NODIRECT)
8641                     {
8642                       printf (" NODIRECT");
8643                       val ^= DF_1_NODIRECT;
8644                     }
8645                   if (val & DF_1_IGNMULDEF)
8646                     {
8647                       printf (" IGNMULDEF");
8648                       val ^= DF_1_IGNMULDEF;
8649                     }
8650                   if (val & DF_1_NOKSYMS)
8651                     {
8652                       printf (" NOKSYMS");
8653                       val ^= DF_1_NOKSYMS;
8654                     }
8655                   if (val & DF_1_NOHDR)
8656                     {
8657                       printf (" NOHDR");
8658                       val ^= DF_1_NOHDR;
8659                     }
8660                   if (val & DF_1_EDITED)
8661                     {
8662                       printf (" EDITED");
8663                       val ^= DF_1_EDITED;
8664                     }
8665                   if (val & DF_1_NORELOC)
8666                     {
8667                       printf (" NORELOC");
8668                       val ^= DF_1_NORELOC;
8669                     }
8670                   if (val & DF_1_SYMINTPOSE)
8671                     {
8672                       printf (" SYMINTPOSE");
8673                       val ^= DF_1_SYMINTPOSE;
8674                     }
8675                   if (val & DF_1_GLOBAUDIT)
8676                     {
8677                       printf (" GLOBAUDIT");
8678                       val ^= DF_1_GLOBAUDIT;
8679                     }
8680                   if (val & DF_1_SINGLETON)
8681                     {
8682                       printf (" SINGLETON");
8683                       val ^= DF_1_SINGLETON;
8684                     }
8685                   if (val != 0)
8686                     printf (" %lx", val);
8687                   puts ("");
8688                 }
8689             }
8690           break;
8691
8692         case DT_PLTREL:
8693           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8694           if (do_dynamic)
8695             puts (get_dynamic_type (entry->d_un.d_val));
8696           break;
8697
8698         case DT_NULL    :
8699         case DT_NEEDED  :
8700         case DT_PLTGOT  :
8701         case DT_HASH    :
8702         case DT_STRTAB  :
8703         case DT_SYMTAB  :
8704         case DT_RELA    :
8705         case DT_INIT    :
8706         case DT_FINI    :
8707         case DT_SONAME  :
8708         case DT_RPATH   :
8709         case DT_SYMBOLIC:
8710         case DT_REL     :
8711         case DT_DEBUG   :
8712         case DT_TEXTREL :
8713         case DT_JMPREL  :
8714         case DT_RUNPATH :
8715           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8716
8717           if (do_dynamic)
8718             {
8719               char * name;
8720
8721               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8722                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8723               else
8724                 name = NULL;
8725
8726               if (name)
8727                 {
8728                   switch (entry->d_tag)
8729                     {
8730                     case DT_NEEDED:
8731                       printf (_("Shared library: [%s]"), name);
8732
8733                       if (streq (name, program_interpreter))
8734                         printf (_(" program interpreter"));
8735                       break;
8736
8737                     case DT_SONAME:
8738                       printf (_("Library soname: [%s]"), name);
8739                       break;
8740
8741                     case DT_RPATH:
8742                       printf (_("Library rpath: [%s]"), name);
8743                       break;
8744
8745                     case DT_RUNPATH:
8746                       printf (_("Library runpath: [%s]"), name);
8747                       break;
8748
8749                     default:
8750                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8751                       break;
8752                     }
8753                 }
8754               else
8755                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8756
8757               putchar ('\n');
8758             }
8759           break;
8760
8761         case DT_PLTRELSZ:
8762         case DT_RELASZ  :
8763         case DT_STRSZ   :
8764         case DT_RELSZ   :
8765         case DT_RELAENT :
8766         case DT_SYMENT  :
8767         case DT_RELENT  :
8768           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8769         case DT_PLTPADSZ:
8770         case DT_MOVEENT :
8771         case DT_MOVESZ  :
8772         case DT_INIT_ARRAYSZ:
8773         case DT_FINI_ARRAYSZ:
8774         case DT_GNU_CONFLICTSZ:
8775         case DT_GNU_LIBLISTSZ:
8776           if (do_dynamic)
8777             {
8778               print_vma (entry->d_un.d_val, UNSIGNED);
8779               printf (_(" (bytes)\n"));
8780             }
8781           break;
8782
8783         case DT_VERDEFNUM:
8784         case DT_VERNEEDNUM:
8785         case DT_RELACOUNT:
8786         case DT_RELCOUNT:
8787           if (do_dynamic)
8788             {
8789               print_vma (entry->d_un.d_val, UNSIGNED);
8790               putchar ('\n');
8791             }
8792           break;
8793
8794         case DT_SYMINSZ:
8795         case DT_SYMINENT:
8796         case DT_SYMINFO:
8797         case DT_USED:
8798         case DT_INIT_ARRAY:
8799         case DT_FINI_ARRAY:
8800           if (do_dynamic)
8801             {
8802               if (entry->d_tag == DT_USED
8803                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8804                 {
8805                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8806
8807                   if (*name)
8808                     {
8809                       printf (_("Not needed object: [%s]\n"), name);
8810                       break;
8811                     }
8812                 }
8813
8814               print_vma (entry->d_un.d_val, PREFIX_HEX);
8815               putchar ('\n');
8816             }
8817           break;
8818
8819         case DT_BIND_NOW:
8820           /* The value of this entry is ignored.  */
8821           if (do_dynamic)
8822             putchar ('\n');
8823           break;
8824
8825         case DT_GNU_PRELINKED:
8826           if (do_dynamic)
8827             {
8828               struct tm * tmp;
8829               time_t atime = entry->d_un.d_val;
8830
8831               tmp = gmtime (&atime);
8832               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8833                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8834                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8835
8836             }
8837           break;
8838
8839         case DT_GNU_HASH:
8840           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8841           if (do_dynamic)
8842             {
8843               print_vma (entry->d_un.d_val, PREFIX_HEX);
8844               putchar ('\n');
8845             }
8846           break;
8847
8848         default:
8849           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8850             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8851               entry->d_un.d_val;
8852
8853           if (do_dynamic)
8854             {
8855               switch (elf_header.e_machine)
8856                 {
8857                 case EM_MIPS:
8858                 case EM_MIPS_RS3_LE:
8859                   dynamic_section_mips_val (entry);
8860                   break;
8861                 case EM_PARISC:
8862                   dynamic_section_parisc_val (entry);
8863                   break;
8864                 case EM_IA_64:
8865                   dynamic_section_ia64_val (entry);
8866                   break;
8867                 default:
8868                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8869                   putchar ('\n');
8870                 }
8871             }
8872           break;
8873         }
8874     }
8875
8876   return 1;
8877 }
8878
8879 static char *
8880 get_ver_flags (unsigned int flags)
8881 {
8882   static char buff[32];
8883
8884   buff[0] = 0;
8885
8886   if (flags == 0)
8887     return _("none");
8888
8889   if (flags & VER_FLG_BASE)
8890     strcat (buff, "BASE ");
8891
8892   if (flags & VER_FLG_WEAK)
8893     {
8894       if (flags & VER_FLG_BASE)
8895         strcat (buff, "| ");
8896
8897       strcat (buff, "WEAK ");
8898     }
8899
8900   if (flags & VER_FLG_INFO)
8901     {
8902       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8903         strcat (buff, "| ");
8904
8905       strcat (buff, "INFO ");
8906     }
8907
8908   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8909     strcat (buff, _("| <unknown>"));
8910
8911   return buff;
8912 }
8913
8914 /* Display the contents of the version sections.  */
8915
8916 static int
8917 process_version_sections (FILE * file)
8918 {
8919   Elf_Internal_Shdr * section;
8920   unsigned i;
8921   int found = 0;
8922
8923   if (! do_version)
8924     return 1;
8925
8926   for (i = 0, section = section_headers;
8927        i < elf_header.e_shnum;
8928        i++, section++)
8929     {
8930       switch (section->sh_type)
8931         {
8932         case SHT_GNU_verdef:
8933           {
8934             Elf_External_Verdef * edefs;
8935             unsigned int idx;
8936             unsigned int cnt;
8937             char * endbuf;
8938
8939             found = 1;
8940
8941             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
8942                     printable_section_name (section),
8943                     section->sh_info);
8944
8945             printf (_("  Addr: 0x"));
8946             printf_vma (section->sh_addr);
8947             printf (_("  Offset: %#08lx  Link: %u (%s)"),
8948                     (unsigned long) section->sh_offset, section->sh_link,
8949                     printable_section_name_from_index (section->sh_link));
8950
8951             edefs = (Elf_External_Verdef *)
8952                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8953                           _("version definition section"));
8954             if (!edefs)
8955               break;
8956             endbuf = (char *) edefs + section->sh_size;
8957
8958             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8959               {
8960                 char * vstart;
8961                 Elf_External_Verdef * edef;
8962                 Elf_Internal_Verdef ent;
8963                 Elf_External_Verdaux * eaux;
8964                 Elf_Internal_Verdaux aux;
8965                 int j;
8966                 int isum;
8967
8968                 /* Check for very large indicies.  */
8969                 if (idx > (size_t) (endbuf - (char *) edefs))
8970                   break;
8971
8972                 vstart = ((char *) edefs) + idx;
8973                 if (vstart + sizeof (*edef) > endbuf)
8974                   break;
8975
8976                 edef = (Elf_External_Verdef *) vstart;
8977
8978                 ent.vd_version = BYTE_GET (edef->vd_version);
8979                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8980                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8981                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8982                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8983                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8984                 ent.vd_next    = BYTE_GET (edef->vd_next);
8985
8986                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8987                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8988
8989                 printf (_("  Index: %d  Cnt: %d  "),
8990                         ent.vd_ndx, ent.vd_cnt);
8991
8992                 /* Check for overflow.  */
8993                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8994                   break;
8995
8996                 vstart += ent.vd_aux;
8997
8998                 eaux = (Elf_External_Verdaux *) vstart;
8999
9000                 aux.vda_name = BYTE_GET (eaux->vda_name);
9001                 aux.vda_next = BYTE_GET (eaux->vda_next);
9002
9003                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9004                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9005                 else
9006                   printf (_("Name index: %ld\n"), aux.vda_name);
9007
9008                 isum = idx + ent.vd_aux;
9009
9010                 for (j = 1; j < ent.vd_cnt; j++)
9011                   {
9012                     /* Check for overflow.  */
9013                     if (aux.vda_next > (size_t) (endbuf - vstart))
9014                       break;
9015
9016                     isum   += aux.vda_next;
9017                     vstart += aux.vda_next;
9018
9019                     eaux = (Elf_External_Verdaux *) vstart;
9020                     if (vstart + sizeof (*eaux) > endbuf)
9021                       break;
9022
9023                     aux.vda_name = BYTE_GET (eaux->vda_name);
9024                     aux.vda_next = BYTE_GET (eaux->vda_next);
9025
9026                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9027                       printf (_("  %#06x: Parent %d: %s\n"),
9028                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9029                     else
9030                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9031                               isum, j, aux.vda_name);
9032                   }
9033
9034                 if (j < ent.vd_cnt)
9035                   printf (_("  Version def aux past end of section\n"));
9036
9037                 idx += ent.vd_next;
9038               }
9039
9040             if (cnt < section->sh_info)
9041               printf (_("  Version definition past end of section\n"));
9042
9043             free (edefs);
9044           }
9045           break;
9046
9047         case SHT_GNU_verneed:
9048           {
9049             Elf_External_Verneed * eneed;
9050             unsigned int idx;
9051             unsigned int cnt;
9052             char * endbuf;
9053
9054             found = 1;
9055
9056             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9057                     printable_section_name (section), section->sh_info);
9058
9059             printf (_(" Addr: 0x"));
9060             printf_vma (section->sh_addr);
9061             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9062                     (unsigned long) section->sh_offset, section->sh_link,
9063                     printable_section_name_from_index (section->sh_link));
9064
9065             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9066                                                        section->sh_offset, 1,
9067                                                        section->sh_size,
9068                                                        _("Version Needs section"));
9069             if (!eneed)
9070               break;
9071             endbuf = (char *) eneed + section->sh_size;
9072
9073             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9074               {
9075                 Elf_External_Verneed * entry;
9076                 Elf_Internal_Verneed ent;
9077                 int j;
9078                 int isum;
9079                 char * vstart;
9080
9081                 if (idx > (size_t) (endbuf - (char *) eneed))
9082                   break;
9083
9084                 vstart = ((char *) eneed) + idx;
9085                 if (vstart + sizeof (*entry) > endbuf)
9086                   break;
9087
9088                 entry = (Elf_External_Verneed *) vstart;
9089
9090                 ent.vn_version = BYTE_GET (entry->vn_version);
9091                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9092                 ent.vn_file    = BYTE_GET (entry->vn_file);
9093                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9094                 ent.vn_next    = BYTE_GET (entry->vn_next);
9095
9096                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9097
9098                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9099                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9100                 else
9101                   printf (_("  File: %lx"), ent.vn_file);
9102
9103                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9104
9105                 /* Check for overflow.  */
9106                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9107                   break;
9108
9109                 vstart += ent.vn_aux;
9110
9111                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9112                   {
9113                     Elf_External_Vernaux * eaux;
9114                     Elf_Internal_Vernaux aux;
9115
9116                     if (vstart + sizeof (*eaux) > endbuf)
9117                       break;
9118                     eaux = (Elf_External_Vernaux *) vstart;
9119
9120                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9121                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9122                     aux.vna_other = BYTE_GET (eaux->vna_other);
9123                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9124                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9125
9126                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9127                       printf (_("  %#06x:   Name: %s"),
9128                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9129                     else
9130                       printf (_("  %#06x:   Name index: %lx"),
9131                               isum, aux.vna_name);
9132
9133                     printf (_("  Flags: %s  Version: %d\n"),
9134                             get_ver_flags (aux.vna_flags), aux.vna_other);
9135
9136                     /* Check for overflow.  */
9137                     if (aux.vna_next > (size_t) (endbuf - vstart))
9138                       break;
9139
9140                     isum   += aux.vna_next;
9141                     vstart += aux.vna_next;
9142                   }
9143
9144                 if (j < ent.vn_cnt)
9145                   warn (_("Missing Version Needs auxillary information\n"));
9146
9147                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9148                   {
9149                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9150                     cnt = section->sh_info;
9151                     break;
9152                   }
9153                 idx += ent.vn_next;
9154               }
9155
9156             if (cnt < section->sh_info)
9157               warn (_("Missing Version Needs information\n"));
9158
9159             free (eneed);
9160           }
9161           break;
9162
9163         case SHT_GNU_versym:
9164           {
9165             Elf_Internal_Shdr * link_section;
9166             int total;
9167             int cnt;
9168             unsigned char * edata;
9169             unsigned short * data;
9170             char * strtab;
9171             Elf_Internal_Sym * symbols;
9172             Elf_Internal_Shdr * string_sec;
9173             unsigned long num_syms;
9174             long off;
9175
9176             if (section->sh_link >= elf_header.e_shnum)
9177               break;
9178
9179             link_section = section_headers + section->sh_link;
9180             total = section->sh_size / sizeof (Elf_External_Versym);
9181
9182             if (link_section->sh_link >= elf_header.e_shnum)
9183               break;
9184
9185             found = 1;
9186
9187             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9188             if (symbols == NULL)
9189               break;
9190
9191             string_sec = section_headers + link_section->sh_link;
9192
9193             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9194                                         string_sec->sh_size,
9195                                         _("version string table"));
9196             if (!strtab)
9197               {
9198                 free (symbols);
9199                 break;
9200               }
9201
9202             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9203                     printable_section_name (section), total);
9204
9205             printf (_(" Addr: "));
9206             printf_vma (section->sh_addr);
9207             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9208                     (unsigned long) section->sh_offset, section->sh_link,
9209                     printable_section_name (link_section));
9210
9211             off = offset_from_vma (file,
9212                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9213                                    total * sizeof (short));
9214             edata = (unsigned char *) get_data (NULL, file, off, total,
9215                                                 sizeof (short),
9216                                                 _("version symbol data"));
9217             if (!edata)
9218               {
9219                 free (strtab);
9220                 free (symbols);
9221                 break;
9222               }
9223
9224             data = (short unsigned int *) cmalloc (total, sizeof (short));
9225
9226             for (cnt = total; cnt --;)
9227               data[cnt] = byte_get (edata + cnt * sizeof (short),
9228                                     sizeof (short));
9229
9230             free (edata);
9231
9232             for (cnt = 0; cnt < total; cnt += 4)
9233               {
9234                 int j, nn;
9235                 int check_def, check_need;
9236                 char * name;
9237
9238                 printf ("  %03x:", cnt);
9239
9240                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9241                   switch (data[cnt + j])
9242                     {
9243                     case 0:
9244                       fputs (_("   0 (*local*)    "), stdout);
9245                       break;
9246
9247                     case 1:
9248                       fputs (_("   1 (*global*)   "), stdout);
9249                       break;
9250
9251                     default:
9252                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9253                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9254
9255                       /* If this index value is greater than the size of the symbols
9256                          array, break to avoid an out-of-bounds read.  */
9257                       if ((unsigned long)(cnt + j) >= num_syms)
9258                         {
9259                           warn (_("invalid index into symbol array\n"));
9260                           break;
9261                         }
9262
9263                       check_def = 1;
9264                       check_need = 1;
9265                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9266                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9267                              != SHT_NOBITS)
9268                         {
9269                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9270                             check_def = 0;
9271                           else
9272                             check_need = 0;
9273                         }
9274
9275                       if (check_need
9276                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9277                         {
9278                           Elf_Internal_Verneed ivn;
9279                           unsigned long offset;
9280
9281                           offset = offset_from_vma
9282                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9283                              sizeof (Elf_External_Verneed));
9284
9285                           do
9286                             {
9287                               Elf_Internal_Vernaux ivna;
9288                               Elf_External_Verneed evn;
9289                               Elf_External_Vernaux evna;
9290                               unsigned long a_off;
9291
9292                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9293                                             _("version need")) == NULL)
9294                                 break;
9295
9296                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9297                               ivn.vn_next = BYTE_GET (evn.vn_next);
9298
9299                               a_off = offset + ivn.vn_aux;
9300
9301                               do
9302                                 {
9303                                   if (get_data (&evna, file, a_off, sizeof (evna),
9304                                                 1, _("version need aux (2)")) == NULL)
9305                                     {
9306                                       ivna.vna_next  = 0;
9307                                       ivna.vna_other = 0;
9308                                     }
9309                                   else
9310                                     {
9311                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9312                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9313                                     }
9314
9315                                   a_off += ivna.vna_next;
9316                                 }
9317                               while (ivna.vna_other != data[cnt + j]
9318                                      && ivna.vna_next != 0);
9319
9320                               if (ivna.vna_other == data[cnt + j])
9321                                 {
9322                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9323
9324                                   if (ivna.vna_name >= string_sec->sh_size)
9325                                     name = _("*invalid*");
9326                                   else
9327                                     name = strtab + ivna.vna_name;
9328                                   nn += printf ("(%s%-*s",
9329                                                 name,
9330                                                 12 - (int) strlen (name),
9331                                                 ")");
9332                                   check_def = 0;
9333                                   break;
9334                                 }
9335
9336                               offset += ivn.vn_next;
9337                             }
9338                           while (ivn.vn_next);
9339                         }
9340
9341                       if (check_def && data[cnt + j] != 0x8001
9342                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9343                         {
9344                           Elf_Internal_Verdef ivd;
9345                           Elf_External_Verdef evd;
9346                           unsigned long offset;
9347
9348                           offset = offset_from_vma
9349                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9350                              sizeof evd);
9351
9352                           do
9353                             {
9354                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9355                                             _("version def")) == NULL)
9356                                 {
9357                                   ivd.vd_next = 0;
9358                                   ivd.vd_ndx  = 0;
9359                                 }
9360                               else
9361                                 {
9362                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9363                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9364                                 }
9365
9366                               offset += ivd.vd_next;
9367                             }
9368                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9369                                  && ivd.vd_next != 0);
9370
9371                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9372                             {
9373                               Elf_External_Verdaux evda;
9374                               Elf_Internal_Verdaux ivda;
9375
9376                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9377
9378                               if (get_data (&evda, file,
9379                                             offset - ivd.vd_next + ivd.vd_aux,
9380                                             sizeof (evda), 1,
9381                                             _("version def aux")) == NULL)
9382                                 break;
9383
9384                               ivda.vda_name = BYTE_GET (evda.vda_name);
9385
9386                               if (ivda.vda_name >= string_sec->sh_size)
9387                                 name = _("*invalid*");
9388                               else
9389                                 name = strtab + ivda.vda_name;
9390                               nn += printf ("(%s%-*s",
9391                                             name,
9392                                             12 - (int) strlen (name),
9393                                             ")");
9394                             }
9395                         }
9396
9397                       if (nn < 18)
9398                         printf ("%*c", 18 - nn, ' ');
9399                     }
9400
9401                 putchar ('\n');
9402               }
9403
9404             free (data);
9405             free (strtab);
9406             free (symbols);
9407           }
9408           break;
9409
9410         default:
9411           break;
9412         }
9413     }
9414
9415   if (! found)
9416     printf (_("\nNo version information found in this file.\n"));
9417
9418   return 1;
9419 }
9420
9421 static const char *
9422 get_symbol_binding (unsigned int binding)
9423 {
9424   static char buff[32];
9425
9426   switch (binding)
9427     {
9428     case STB_LOCAL:     return "LOCAL";
9429     case STB_GLOBAL:    return "GLOBAL";
9430     case STB_WEAK:      return "WEAK";
9431     default:
9432       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9433         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9434                   binding);
9435       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9436         {
9437           if (binding == STB_GNU_UNIQUE
9438               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9439                   /* GNU is still using the default value 0.  */
9440                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9441             return "UNIQUE";
9442           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9443         }
9444       else
9445         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9446       return buff;
9447     }
9448 }
9449
9450 static const char *
9451 get_symbol_type (unsigned int type)
9452 {
9453   static char buff[32];
9454
9455   switch (type)
9456     {
9457     case STT_NOTYPE:    return "NOTYPE";
9458     case STT_OBJECT:    return "OBJECT";
9459     case STT_FUNC:      return "FUNC";
9460     case STT_SECTION:   return "SECTION";
9461     case STT_FILE:      return "FILE";
9462     case STT_COMMON:    return "COMMON";
9463     case STT_TLS:       return "TLS";
9464     case STT_RELC:      return "RELC";
9465     case STT_SRELC:     return "SRELC";
9466     default:
9467       if (type >= STT_LOPROC && type <= STT_HIPROC)
9468         {
9469           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9470             return "THUMB_FUNC";
9471
9472           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9473             return "REGISTER";
9474
9475           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9476             return "PARISC_MILLI";
9477
9478           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9479         }
9480       else if (type >= STT_LOOS && type <= STT_HIOS)
9481         {
9482           if (elf_header.e_machine == EM_PARISC)
9483             {
9484               if (type == STT_HP_OPAQUE)
9485                 return "HP_OPAQUE";
9486               if (type == STT_HP_STUB)
9487                 return "HP_STUB";
9488             }
9489
9490           if (type == STT_GNU_IFUNC
9491               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9492                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9493                   /* GNU is still using the default value 0.  */
9494                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9495             return "IFUNC";
9496
9497           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9498         }
9499       else
9500         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9501       return buff;
9502     }
9503 }
9504
9505 static const char *
9506 get_symbol_visibility (unsigned int visibility)
9507 {
9508   switch (visibility)
9509     {
9510     case STV_DEFAULT:   return "DEFAULT";
9511     case STV_INTERNAL:  return "INTERNAL";
9512     case STV_HIDDEN:    return "HIDDEN";
9513     case STV_PROTECTED: return "PROTECTED";
9514     default: abort ();
9515     }
9516 }
9517
9518 static const char *
9519 get_mips_symbol_other (unsigned int other)
9520 {
9521   switch (other)
9522     {
9523     case STO_OPTIONAL:
9524       return "OPTIONAL";
9525     case STO_MIPS_PLT:
9526       return "MIPS PLT";
9527     case STO_MIPS_PIC:
9528       return "MIPS PIC";
9529     case STO_MICROMIPS:
9530       return "MICROMIPS";
9531     case STO_MICROMIPS | STO_MIPS_PIC:
9532       return "MICROMIPS, MIPS PIC";
9533     case STO_MIPS16:
9534       return "MIPS16";
9535     default:
9536       return NULL;
9537     }
9538 }
9539
9540 static const char *
9541 get_ia64_symbol_other (unsigned int other)
9542 {
9543   if (is_ia64_vms ())
9544     {
9545       static char res[32];
9546
9547       res[0] = 0;
9548
9549       /* Function types is for images and .STB files only.  */
9550       switch (elf_header.e_type)
9551         {
9552         case ET_DYN:
9553         case ET_EXEC:
9554           switch (VMS_ST_FUNC_TYPE (other))
9555             {
9556             case VMS_SFT_CODE_ADDR:
9557               strcat (res, " CA");
9558               break;
9559             case VMS_SFT_SYMV_IDX:
9560               strcat (res, " VEC");
9561               break;
9562             case VMS_SFT_FD:
9563               strcat (res, " FD");
9564               break;
9565             case VMS_SFT_RESERVE:
9566               strcat (res, " RSV");
9567               break;
9568             default:
9569               abort ();
9570             }
9571           break;
9572         default:
9573           break;
9574         }
9575       switch (VMS_ST_LINKAGE (other))
9576         {
9577         case VMS_STL_IGNORE:
9578           strcat (res, " IGN");
9579           break;
9580         case VMS_STL_RESERVE:
9581           strcat (res, " RSV");
9582           break;
9583         case VMS_STL_STD:
9584           strcat (res, " STD");
9585           break;
9586         case VMS_STL_LNK:
9587           strcat (res, " LNK");
9588           break;
9589         default:
9590           abort ();
9591         }
9592
9593       if (res[0] != 0)
9594         return res + 1;
9595       else
9596         return res;
9597     }
9598   return NULL;
9599 }
9600
9601 static const char *
9602 get_ppc64_symbol_other (unsigned int other)
9603 {
9604   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9605     {
9606       static char buf[32];
9607       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9608                 PPC64_LOCAL_ENTRY_OFFSET (other));
9609       return buf;
9610     }
9611   return NULL;
9612 }
9613
9614 static const char *
9615 get_symbol_other (unsigned int other)
9616 {
9617   const char * result = NULL;
9618   static char buff [32];
9619
9620   if (other == 0)
9621     return "";
9622
9623   switch (elf_header.e_machine)
9624     {
9625     case EM_MIPS:
9626       result = get_mips_symbol_other (other);
9627       break;
9628     case EM_IA_64:
9629       result = get_ia64_symbol_other (other);
9630       break;
9631     case EM_PPC64:
9632       result = get_ppc64_symbol_other (other);
9633       break;
9634     default:
9635       break;
9636     }
9637
9638   if (result)
9639     return result;
9640
9641   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9642   return buff;
9643 }
9644
9645 static const char *
9646 get_symbol_index_type (unsigned int type)
9647 {
9648   static char buff[32];
9649
9650   switch (type)
9651     {
9652     case SHN_UNDEF:     return "UND";
9653     case SHN_ABS:       return "ABS";
9654     case SHN_COMMON:    return "COM";
9655     default:
9656       if (type == SHN_IA_64_ANSI_COMMON
9657           && elf_header.e_machine == EM_IA_64
9658           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9659         return "ANSI_COM";
9660       else if ((elf_header.e_machine == EM_X86_64
9661                 || elf_header.e_machine == EM_L1OM
9662                 || elf_header.e_machine == EM_K1OM)
9663                && type == SHN_X86_64_LCOMMON)
9664         return "LARGE_COM";
9665       else if ((type == SHN_MIPS_SCOMMON
9666                 && elf_header.e_machine == EM_MIPS)
9667                || (type == SHN_TIC6X_SCOMMON
9668                    && elf_header.e_machine == EM_TI_C6000))
9669         return "SCOM";
9670       else if (type == SHN_MIPS_SUNDEFINED
9671                && elf_header.e_machine == EM_MIPS)
9672         return "SUND";
9673       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9674         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9675       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9676         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9677       else if (type >= SHN_LORESERVE)
9678         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9679       else if (type >= elf_header.e_shnum)
9680         sprintf (buff, _("bad section index[%3d]"), type);
9681       else
9682         sprintf (buff, "%3d", type);
9683       break;
9684     }
9685
9686   return buff;
9687 }
9688
9689 static bfd_vma *
9690 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9691 {
9692   unsigned char * e_data;
9693   bfd_vma * i_data;
9694
9695   e_data = (unsigned char *) cmalloc (number, ent_size);
9696
9697   if (e_data == NULL)
9698     {
9699       error (_("Out of memory\n"));
9700       return NULL;
9701     }
9702
9703   if (fread (e_data, ent_size, number, file) != number)
9704     {
9705       error (_("Unable to read in dynamic data\n"));
9706       return NULL;
9707     }
9708
9709   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9710
9711   if (i_data == NULL)
9712     {
9713       error (_("Out of memory\n"));
9714       free (e_data);
9715       return NULL;
9716     }
9717
9718   while (number--)
9719     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9720
9721   free (e_data);
9722
9723   return i_data;
9724 }
9725
9726 static void
9727 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9728 {
9729   Elf_Internal_Sym * psym;
9730   int n;
9731
9732   n = print_vma (si, DEC_5);
9733   if (n < 5)
9734     fputs (&"     "[n], stdout);
9735   printf (" %3lu: ", hn);
9736
9737   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9738     {
9739       printf (_("<No info available>\n"));
9740       return;
9741     }
9742
9743   psym = dynamic_symbols + si;
9744   print_vma (psym->st_value, LONG_HEX);
9745   putchar (' ');
9746   print_vma (psym->st_size, DEC_5);
9747
9748   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9749   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9750   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9751   /* Check to see if any other bits in the st_other field are set.
9752      Note - displaying this information disrupts the layout of the
9753      table being generated, but for the moment this case is very
9754      rare.  */
9755   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9756     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9757   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9758   if (VALID_DYNAMIC_NAME (psym->st_name))
9759     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9760   else
9761     printf (_(" <corrupt: %14ld>"), psym->st_name);
9762   putchar ('\n');
9763 }
9764
9765 /* Dump the symbol table.  */
9766 static int
9767 process_symbol_table (FILE * file)
9768 {
9769   Elf_Internal_Shdr * section;
9770   bfd_vma nbuckets = 0;
9771   bfd_vma nchains = 0;
9772   bfd_vma * buckets = NULL;
9773   bfd_vma * chains = NULL;
9774   bfd_vma ngnubuckets = 0;
9775   bfd_vma * gnubuckets = NULL;
9776   bfd_vma * gnuchains = NULL;
9777   bfd_vma gnusymidx = 0;
9778
9779   if (!do_syms && !do_dyn_syms && !do_histogram)
9780     return 1;
9781
9782   if (dynamic_info[DT_HASH]
9783       && (do_histogram
9784           || (do_using_dynamic
9785               && !do_dyn_syms
9786               && dynamic_strings != NULL)))
9787     {
9788       unsigned char nb[8];
9789       unsigned char nc[8];
9790       int hash_ent_size = 4;
9791
9792       if ((elf_header.e_machine == EM_ALPHA
9793            || elf_header.e_machine == EM_S390
9794            || elf_header.e_machine == EM_S390_OLD)
9795           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9796         hash_ent_size = 8;
9797
9798       if (fseek (file,
9799                  (archive_file_offset
9800                   + offset_from_vma (file, dynamic_info[DT_HASH],
9801                                      sizeof nb + sizeof nc)),
9802                  SEEK_SET))
9803         {
9804           error (_("Unable to seek to start of dynamic information\n"));
9805           goto no_hash;
9806         }
9807
9808       if (fread (nb, hash_ent_size, 1, file) != 1)
9809         {
9810           error (_("Failed to read in number of buckets\n"));
9811           goto no_hash;
9812         }
9813
9814       if (fread (nc, hash_ent_size, 1, file) != 1)
9815         {
9816           error (_("Failed to read in number of chains\n"));
9817           goto no_hash;
9818         }
9819
9820       nbuckets = byte_get (nb, hash_ent_size);
9821       nchains  = byte_get (nc, hash_ent_size);
9822
9823       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9824       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9825
9826     no_hash:
9827       if (buckets == NULL || chains == NULL)
9828         {
9829           if (do_using_dynamic)
9830             return 0;
9831           free (buckets);
9832           free (chains);
9833           buckets = NULL;
9834           chains = NULL;
9835           nbuckets = 0;
9836           nchains = 0;
9837         }
9838     }
9839
9840   if (dynamic_info_DT_GNU_HASH
9841       && (do_histogram
9842           || (do_using_dynamic
9843               && !do_dyn_syms
9844               && dynamic_strings != NULL)))
9845     {
9846       unsigned char nb[16];
9847       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9848       bfd_vma buckets_vma;
9849
9850       if (fseek (file,
9851                  (archive_file_offset
9852                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9853                                      sizeof nb)),
9854                  SEEK_SET))
9855         {
9856           error (_("Unable to seek to start of dynamic information\n"));
9857           goto no_gnu_hash;
9858         }
9859
9860       if (fread (nb, 16, 1, file) != 1)
9861         {
9862           error (_("Failed to read in number of buckets\n"));
9863           goto no_gnu_hash;
9864         }
9865
9866       ngnubuckets = byte_get (nb, 4);
9867       gnusymidx = byte_get (nb + 4, 4);
9868       bitmaskwords = byte_get (nb + 8, 4);
9869       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9870       if (is_32bit_elf)
9871         buckets_vma += bitmaskwords * 4;
9872       else
9873         buckets_vma += bitmaskwords * 8;
9874
9875       if (fseek (file,
9876                  (archive_file_offset
9877                   + offset_from_vma (file, buckets_vma, 4)),
9878                  SEEK_SET))
9879         {
9880           error (_("Unable to seek to start of dynamic information\n"));
9881           goto no_gnu_hash;
9882         }
9883
9884       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9885
9886       if (gnubuckets == NULL)
9887         goto no_gnu_hash;
9888
9889       for (i = 0; i < ngnubuckets; i++)
9890         if (gnubuckets[i] != 0)
9891           {
9892             if (gnubuckets[i] < gnusymidx)
9893               return 0;
9894
9895             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9896               maxchain = gnubuckets[i];
9897           }
9898
9899       if (maxchain == 0xffffffff)
9900         goto no_gnu_hash;
9901
9902       maxchain -= gnusymidx;
9903
9904       if (fseek (file,
9905                  (archive_file_offset
9906                   + offset_from_vma (file, buckets_vma
9907                                            + 4 * (ngnubuckets + maxchain), 4)),
9908                  SEEK_SET))
9909         {
9910           error (_("Unable to seek to start of dynamic information\n"));
9911           goto no_gnu_hash;
9912         }
9913
9914       do
9915         {
9916           if (fread (nb, 4, 1, file) != 1)
9917             {
9918               error (_("Failed to determine last chain length\n"));
9919               goto no_gnu_hash;
9920             }
9921
9922           if (maxchain + 1 == 0)
9923             goto no_gnu_hash;
9924
9925           ++maxchain;
9926         }
9927       while ((byte_get (nb, 4) & 1) == 0);
9928
9929       if (fseek (file,
9930                  (archive_file_offset
9931                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9932                  SEEK_SET))
9933         {
9934           error (_("Unable to seek to start of dynamic information\n"));
9935           goto no_gnu_hash;
9936         }
9937
9938       gnuchains = get_dynamic_data (file, maxchain, 4);
9939
9940     no_gnu_hash:
9941       if (gnuchains == NULL)
9942         {
9943           free (gnubuckets);
9944           gnubuckets = NULL;
9945           ngnubuckets = 0;
9946           if (do_using_dynamic)
9947             return 0;
9948         }
9949     }
9950
9951   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9952       && do_syms
9953       && do_using_dynamic
9954       && dynamic_strings != NULL)
9955     {
9956       unsigned long hn;
9957
9958       if (dynamic_info[DT_HASH])
9959         {
9960           bfd_vma si;
9961
9962           printf (_("\nSymbol table for image:\n"));
9963           if (is_32bit_elf)
9964             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9965           else
9966             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9967
9968           for (hn = 0; hn < nbuckets; hn++)
9969             {
9970               if (! buckets[hn])
9971                 continue;
9972
9973               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9974                 print_dynamic_symbol (si, hn);
9975             }
9976         }
9977
9978       if (dynamic_info_DT_GNU_HASH)
9979         {
9980           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9981           if (is_32bit_elf)
9982             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9983           else
9984             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9985
9986           for (hn = 0; hn < ngnubuckets; ++hn)
9987             if (gnubuckets[hn] != 0)
9988               {
9989                 bfd_vma si = gnubuckets[hn];
9990                 bfd_vma off = si - gnusymidx;
9991
9992                 do
9993                   {
9994                     print_dynamic_symbol (si, hn);
9995                     si++;
9996                   }
9997                 while ((gnuchains[off++] & 1) == 0);
9998               }
9999         }
10000     }
10001   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
10002     {
10003       unsigned int i;
10004
10005       for (i = 0, section = section_headers;
10006            i < elf_header.e_shnum;
10007            i++, section++)
10008         {
10009           unsigned int si;
10010           char * strtab = NULL;
10011           unsigned long int strtab_size = 0;
10012           Elf_Internal_Sym * symtab;
10013           Elf_Internal_Sym * psym;
10014           unsigned long num_syms;
10015
10016           if ((section->sh_type != SHT_SYMTAB
10017                && section->sh_type != SHT_DYNSYM)
10018               || (!do_syms
10019                   && section->sh_type == SHT_SYMTAB))
10020             continue;
10021
10022           if (section->sh_entsize == 0)
10023             {
10024               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10025                       printable_section_name (section));
10026               continue;
10027             }
10028
10029           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10030                   printable_section_name (section),
10031                   (unsigned long) (section->sh_size / section->sh_entsize));
10032
10033           if (is_32bit_elf)
10034             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10035           else
10036             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10037
10038           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10039           if (symtab == NULL)
10040             continue;
10041
10042           if (section->sh_link == elf_header.e_shstrndx)
10043             {
10044               strtab = string_table;
10045               strtab_size = string_table_length;
10046             }
10047           else if (section->sh_link < elf_header.e_shnum)
10048             {
10049               Elf_Internal_Shdr * string_sec;
10050
10051               string_sec = section_headers + section->sh_link;
10052
10053               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10054                                           1, string_sec->sh_size,
10055                                           _("string table"));
10056               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10057             }
10058
10059           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10060             {
10061               printf ("%6d: ", si);
10062               print_vma (psym->st_value, LONG_HEX);
10063               putchar (' ');
10064               print_vma (psym->st_size, DEC_5);
10065               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10066               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10067               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10068               /* Check to see if any other bits in the st_other field are set.
10069                  Note - displaying this information disrupts the layout of the
10070                  table being generated, but for the moment this case is very rare.  */
10071               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10072                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10073               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10074               print_symbol (25, psym->st_name < strtab_size
10075                             ? strtab + psym->st_name : _("<corrupt>"));
10076
10077               if (section->sh_type == SHT_DYNSYM
10078                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10079                 {
10080                   unsigned char data[2];
10081                   unsigned short vers_data;
10082                   unsigned long offset;
10083                   int is_nobits;
10084                   int check_def;
10085
10086                   offset = offset_from_vma
10087                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10088                      sizeof data + si * sizeof (vers_data));
10089
10090                   if (get_data (&data, file, offset + si * sizeof (vers_data),
10091                                 sizeof (data), 1, _("version data")) == NULL)
10092                     break;
10093
10094                   vers_data = byte_get (data, 2);
10095
10096                   is_nobits = (psym->st_shndx < elf_header.e_shnum
10097                                && section_headers[psym->st_shndx].sh_type
10098                                   == SHT_NOBITS);
10099
10100                   check_def = (psym->st_shndx != SHN_UNDEF);
10101
10102                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10103                     {
10104                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10105                           && (is_nobits || ! check_def))
10106                         {
10107                           Elf_External_Verneed evn;
10108                           Elf_Internal_Verneed ivn;
10109                           Elf_Internal_Vernaux ivna;
10110
10111                           /* We must test both.  */
10112                           offset = offset_from_vma
10113                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10114                              sizeof evn);
10115
10116                           do
10117                             {
10118                               unsigned long vna_off;
10119
10120                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10121                                             _("version need")) == NULL)
10122                                 {
10123                                   ivna.vna_next = 0;
10124                                   ivna.vna_other = 0;
10125                                   ivna.vna_name = 0;
10126                                   break;
10127                                 }
10128
10129                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10130                               ivn.vn_next = BYTE_GET (evn.vn_next);
10131
10132                               vna_off = offset + ivn.vn_aux;
10133
10134                               do
10135                                 {
10136                                   Elf_External_Vernaux evna;
10137
10138                                   if (get_data (&evna, file, vna_off,
10139                                                 sizeof (evna), 1,
10140                                                 _("version need aux (3)")) == NULL)
10141                                     {
10142                                       ivna.vna_next = 0;
10143                                       ivna.vna_other = 0;
10144                                       ivna.vna_name = 0;
10145                                     }
10146                                   else
10147                                     {
10148                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10149                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10150                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
10151                                     }
10152
10153                                   vna_off += ivna.vna_next;
10154                                 }
10155                               while (ivna.vna_other != vers_data
10156                                      && ivna.vna_next != 0);
10157
10158                               if (ivna.vna_other == vers_data)
10159                                 break;
10160
10161                               offset += ivn.vn_next;
10162                             }
10163                           while (ivn.vn_next != 0);
10164
10165                           if (ivna.vna_other == vers_data)
10166                             {
10167                               printf ("@%s (%d)",
10168                                       ivna.vna_name < strtab_size
10169                                       ? strtab + ivna.vna_name : _("<corrupt>"),
10170                                       ivna.vna_other);
10171                               check_def = 0;
10172                             }
10173                           else if (! is_nobits)
10174                             error (_("bad dynamic symbol\n"));
10175                           else
10176                             check_def = 1;
10177                         }
10178
10179                       if (check_def)
10180                         {
10181                           if (vers_data != 0x8001
10182                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10183                             {
10184                               Elf_Internal_Verdef ivd;
10185                               Elf_Internal_Verdaux ivda;
10186                               Elf_External_Verdaux evda;
10187                               unsigned long off;
10188
10189                               off = offset_from_vma
10190                                 (file,
10191                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10192                                  sizeof (Elf_External_Verdef));
10193
10194                               do
10195                                 {
10196                                   Elf_External_Verdef evd;
10197
10198                                   if (get_data (&evd, file, off, sizeof (evd),
10199                                                 1, _("version def")) == NULL)
10200                                     {
10201                                       ivd.vd_ndx = 0;
10202                                       ivd.vd_aux = 0;
10203                                       ivd.vd_next = 0;
10204                                     }
10205                                   else
10206                                     {
10207                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10208                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
10209                                       ivd.vd_next = BYTE_GET (evd.vd_next);
10210                                     }
10211
10212                                   off += ivd.vd_next;
10213                                 }
10214                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10215                                      && ivd.vd_next != 0);
10216
10217                               off -= ivd.vd_next;
10218                               off += ivd.vd_aux;
10219
10220                               if (get_data (&evda, file, off, sizeof (evda),
10221                                             1, _("version def aux")) == NULL)
10222                                 break;
10223
10224                               ivda.vda_name = BYTE_GET (evda.vda_name);
10225
10226                               if (psym->st_name != ivda.vda_name)
10227                                 printf ((vers_data & VERSYM_HIDDEN)
10228                                         ? "@%s" : "@@%s",
10229                                         ivda.vda_name < strtab_size
10230                                         ? strtab + ivda.vda_name : _("<corrupt>"));
10231                             }
10232                         }
10233                     }
10234                 }
10235
10236               putchar ('\n');
10237             }
10238
10239           free (symtab);
10240           if (strtab != string_table)
10241             free (strtab);
10242         }
10243     }
10244   else if (do_syms)
10245     printf
10246       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10247
10248   if (do_histogram && buckets != NULL)
10249     {
10250       unsigned long * lengths;
10251       unsigned long * counts;
10252       unsigned long hn;
10253       bfd_vma si;
10254       unsigned long maxlength = 0;
10255       unsigned long nzero_counts = 0;
10256       unsigned long nsyms = 0;
10257
10258       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10259               (unsigned long) nbuckets);
10260       printf (_(" Length  Number     %% of total  Coverage\n"));
10261
10262       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10263       if (lengths == NULL)
10264         {
10265           error (_("Out of memory\n"));
10266           return 0;
10267         }
10268       for (hn = 0; hn < nbuckets; ++hn)
10269         {
10270           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10271             {
10272               ++nsyms;
10273               if (maxlength < ++lengths[hn])
10274                 ++maxlength;
10275
10276               /* PR binutils/17531: A corrupt binary could contain broken
10277                  histogram data.  Do not go into an infinite loop trying
10278                  to process it.  */
10279               if (chains[si] == si)
10280                 {
10281                   error (_("histogram chain links to itself\n"));
10282                   break;
10283                 }
10284             }
10285         }
10286
10287       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10288       if (counts == NULL)
10289         {
10290           free (lengths);
10291           error (_("Out of memory\n"));
10292           return 0;
10293         }
10294
10295       for (hn = 0; hn < nbuckets; ++hn)
10296         ++counts[lengths[hn]];
10297
10298       if (nbuckets > 0)
10299         {
10300           unsigned long i;
10301           printf ("      0  %-10lu (%5.1f%%)\n",
10302                   counts[0], (counts[0] * 100.0) / nbuckets);
10303           for (i = 1; i <= maxlength; ++i)
10304             {
10305               nzero_counts += counts[i] * i;
10306               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10307                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10308                       (nzero_counts * 100.0) / nsyms);
10309             }
10310         }
10311
10312       free (counts);
10313       free (lengths);
10314     }
10315
10316   if (buckets != NULL)
10317     {
10318       free (buckets);
10319       free (chains);
10320     }
10321
10322   if (do_histogram && gnubuckets != NULL)
10323     {
10324       unsigned long * lengths;
10325       unsigned long * counts;
10326       unsigned long hn;
10327       unsigned long maxlength = 0;
10328       unsigned long nzero_counts = 0;
10329       unsigned long nsyms = 0;
10330
10331       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10332       if (lengths == NULL)
10333         {
10334           error (_("Out of memory\n"));
10335           return 0;
10336         }
10337
10338       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10339               (unsigned long) ngnubuckets);
10340       printf (_(" Length  Number     %% of total  Coverage\n"));
10341
10342       for (hn = 0; hn < ngnubuckets; ++hn)
10343         if (gnubuckets[hn] != 0)
10344           {
10345             bfd_vma off, length = 1;
10346
10347             for (off = gnubuckets[hn] - gnusymidx;
10348                  (gnuchains[off] & 1) == 0; ++off)
10349               ++length;
10350             lengths[hn] = length;
10351             if (length > maxlength)
10352               maxlength = length;
10353             nsyms += length;
10354           }
10355
10356       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10357       if (counts == NULL)
10358         {
10359           free (lengths);
10360           error (_("Out of memory\n"));
10361           return 0;
10362         }
10363
10364       for (hn = 0; hn < ngnubuckets; ++hn)
10365         ++counts[lengths[hn]];
10366
10367       if (ngnubuckets > 0)
10368         {
10369           unsigned long j;
10370           printf ("      0  %-10lu (%5.1f%%)\n",
10371                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10372           for (j = 1; j <= maxlength; ++j)
10373             {
10374               nzero_counts += counts[j] * j;
10375               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10376                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10377                       (nzero_counts * 100.0) / nsyms);
10378             }
10379         }
10380
10381       free (counts);
10382       free (lengths);
10383       free (gnubuckets);
10384       free (gnuchains);
10385     }
10386
10387   return 1;
10388 }
10389
10390 static int
10391 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10392 {
10393   unsigned int i;
10394
10395   if (dynamic_syminfo == NULL
10396       || !do_dynamic)
10397     /* No syminfo, this is ok.  */
10398     return 1;
10399
10400   /* There better should be a dynamic symbol section.  */
10401   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10402     return 0;
10403
10404   if (dynamic_addr)
10405     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10406             dynamic_syminfo_offset, dynamic_syminfo_nent);
10407
10408   printf (_(" Num: Name                           BoundTo     Flags\n"));
10409   for (i = 0; i < dynamic_syminfo_nent; ++i)
10410     {
10411       unsigned short int flags = dynamic_syminfo[i].si_flags;
10412
10413       printf ("%4d: ", i);
10414       assert (i <  num_dynamic_syms);
10415       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10416         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10417       else
10418         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10419       putchar (' ');
10420
10421       switch (dynamic_syminfo[i].si_boundto)
10422         {
10423         case SYMINFO_BT_SELF:
10424           fputs ("SELF       ", stdout);
10425           break;
10426         case SYMINFO_BT_PARENT:
10427           fputs ("PARENT     ", stdout);
10428           break;
10429         default:
10430           if (dynamic_syminfo[i].si_boundto > 0
10431               && dynamic_syminfo[i].si_boundto < dynamic_nent
10432               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10433             {
10434               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10435               putchar (' ' );
10436             }
10437           else
10438             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10439           break;
10440         }
10441
10442       if (flags & SYMINFO_FLG_DIRECT)
10443         printf (" DIRECT");
10444       if (flags & SYMINFO_FLG_PASSTHRU)
10445         printf (" PASSTHRU");
10446       if (flags & SYMINFO_FLG_COPY)
10447         printf (" COPY");
10448       if (flags & SYMINFO_FLG_LAZYLOAD)
10449         printf (" LAZYLOAD");
10450
10451       puts ("");
10452     }
10453
10454   return 1;
10455 }
10456
10457 /* Check to see if the given reloc needs to be handled in a target specific
10458    manner.  If so then process the reloc and return TRUE otherwise return
10459    FALSE.  */
10460
10461 static bfd_boolean
10462 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10463                                 unsigned char *     start,
10464                                 Elf_Internal_Sym *  symtab)
10465 {
10466   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10467
10468   switch (elf_header.e_machine)
10469     {
10470     case EM_MSP430:
10471     case EM_MSP430_OLD:
10472       {
10473         static Elf_Internal_Sym * saved_sym = NULL;
10474
10475         switch (reloc_type)
10476           {
10477           case 10: /* R_MSP430_SYM_DIFF */
10478             if (uses_msp430x_relocs ())
10479               break;
10480           case 21: /* R_MSP430X_SYM_DIFF */
10481             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10482             return TRUE;
10483
10484           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10485           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10486             goto handle_sym_diff;
10487
10488           case 5: /* R_MSP430_16_BYTE */
10489           case 9: /* R_MSP430_8 */
10490             if (uses_msp430x_relocs ())
10491               break;
10492             goto handle_sym_diff;
10493
10494           case 2: /* R_MSP430_ABS16 */
10495           case 15: /* R_MSP430X_ABS16 */
10496             if (! uses_msp430x_relocs ())
10497               break;
10498             goto handle_sym_diff;
10499
10500           handle_sym_diff:
10501             if (saved_sym != NULL)
10502               {
10503                 bfd_vma value;
10504
10505                 value = reloc->r_addend
10506                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10507                      - saved_sym->st_value);
10508
10509                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10510
10511                 saved_sym = NULL;
10512                 return TRUE;
10513               }
10514             break;
10515
10516           default:
10517             if (saved_sym != NULL)
10518               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10519             break;
10520           }
10521         break;
10522       }
10523
10524     case EM_MN10300:
10525     case EM_CYGNUS_MN10300:
10526       {
10527         static Elf_Internal_Sym * saved_sym = NULL;
10528
10529         switch (reloc_type)
10530           {
10531           case 34: /* R_MN10300_ALIGN */
10532             return TRUE;
10533           case 33: /* R_MN10300_SYM_DIFF */
10534             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10535             return TRUE;
10536           case 1: /* R_MN10300_32 */
10537           case 2: /* R_MN10300_16 */
10538             if (saved_sym != NULL)
10539               {
10540                 bfd_vma value;
10541
10542                 value = reloc->r_addend
10543                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10544                      - saved_sym->st_value);
10545
10546                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10547
10548                 saved_sym = NULL;
10549                 return TRUE;
10550               }
10551             break;
10552           default:
10553             if (saved_sym != NULL)
10554               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10555             break;
10556           }
10557         break;
10558       }
10559     }
10560
10561   return FALSE;
10562 }
10563
10564 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10565    DWARF debug sections.  This is a target specific test.  Note - we do not
10566    go through the whole including-target-headers-multiple-times route, (as
10567    we have already done with <elf/h8.h>) because this would become very
10568    messy and even then this function would have to contain target specific
10569    information (the names of the relocs instead of their numeric values).
10570    FIXME: This is not the correct way to solve this problem.  The proper way
10571    is to have target specific reloc sizing and typing functions created by
10572    the reloc-macros.h header, in the same way that it already creates the
10573    reloc naming functions.  */
10574
10575 static bfd_boolean
10576 is_32bit_abs_reloc (unsigned int reloc_type)
10577 {
10578   switch (elf_header.e_machine)
10579     {
10580     case EM_386:
10581     case EM_486:
10582       return reloc_type == 1; /* R_386_32.  */
10583     case EM_68K:
10584       return reloc_type == 1; /* R_68K_32.  */
10585     case EM_860:
10586       return reloc_type == 1; /* R_860_32.  */
10587     case EM_960:
10588       return reloc_type == 2; /* R_960_32.  */
10589     case EM_AARCH64:
10590       return reloc_type == 258; /* R_AARCH64_ABS32 */
10591     case EM_ALPHA:
10592       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10593     case EM_ARC:
10594       return reloc_type == 1; /* R_ARC_32.  */
10595     case EM_ARM:
10596       return reloc_type == 2; /* R_ARM_ABS32 */
10597     case EM_AVR_OLD:
10598     case EM_AVR:
10599       return reloc_type == 1;
10600     case EM_ADAPTEVA_EPIPHANY:
10601       return reloc_type == 3;
10602     case EM_BLACKFIN:
10603       return reloc_type == 0x12; /* R_byte4_data.  */
10604     case EM_CRIS:
10605       return reloc_type == 3; /* R_CRIS_32.  */
10606     case EM_CR16:
10607       return reloc_type == 3; /* R_CR16_NUM32.  */
10608     case EM_CRX:
10609       return reloc_type == 15; /* R_CRX_NUM32.  */
10610     case EM_CYGNUS_FRV:
10611       return reloc_type == 1;
10612     case EM_CYGNUS_D10V:
10613     case EM_D10V:
10614       return reloc_type == 6; /* R_D10V_32.  */
10615     case EM_CYGNUS_D30V:
10616     case EM_D30V:
10617       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10618     case EM_DLX:
10619       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10620     case EM_CYGNUS_FR30:
10621     case EM_FR30:
10622       return reloc_type == 3; /* R_FR30_32.  */
10623     case EM_H8S:
10624     case EM_H8_300:
10625     case EM_H8_300H:
10626       return reloc_type == 1; /* R_H8_DIR32.  */
10627     case EM_IA_64:
10628       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10629     case EM_IP2K_OLD:
10630     case EM_IP2K:
10631       return reloc_type == 2; /* R_IP2K_32.  */
10632     case EM_IQ2000:
10633       return reloc_type == 2; /* R_IQ2000_32.  */
10634     case EM_LATTICEMICO32:
10635       return reloc_type == 3; /* R_LM32_32.  */
10636     case EM_M32C_OLD:
10637     case EM_M32C:
10638       return reloc_type == 3; /* R_M32C_32.  */
10639     case EM_M32R:
10640       return reloc_type == 34; /* R_M32R_32_RELA.  */
10641     case EM_MCORE:
10642       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10643     case EM_CYGNUS_MEP:
10644       return reloc_type == 4; /* R_MEP_32.  */
10645     case EM_METAG:
10646       return reloc_type == 2; /* R_METAG_ADDR32.  */
10647     case EM_MICROBLAZE:
10648       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10649     case EM_MIPS:
10650       return reloc_type == 2; /* R_MIPS_32.  */
10651     case EM_MMIX:
10652       return reloc_type == 4; /* R_MMIX_32.  */
10653     case EM_CYGNUS_MN10200:
10654     case EM_MN10200:
10655       return reloc_type == 1; /* R_MN10200_32.  */
10656     case EM_CYGNUS_MN10300:
10657     case EM_MN10300:
10658       return reloc_type == 1; /* R_MN10300_32.  */
10659     case EM_MOXIE:
10660       return reloc_type == 1; /* R_MOXIE_32.  */
10661     case EM_MSP430_OLD:
10662     case EM_MSP430:
10663       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10664     case EM_MT:
10665       return reloc_type == 2; /* R_MT_32.  */
10666     case EM_NDS32:
10667       return reloc_type == 20; /* R_NDS32_RELA.  */
10668     case EM_ALTERA_NIOS2:
10669       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10670     case EM_NIOS32:
10671       return reloc_type == 1; /* R_NIOS_32.  */
10672     case EM_OR1K:
10673       return reloc_type == 1; /* R_OR1K_32.  */
10674     case EM_PARISC:
10675       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10676               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10677     case EM_PJ:
10678     case EM_PJ_OLD:
10679       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10680     case EM_PPC64:
10681       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10682     case EM_PPC:
10683       return reloc_type == 1; /* R_PPC_ADDR32.  */
10684     case EM_RL78:
10685       return reloc_type == 1; /* R_RL78_DIR32.  */
10686     case EM_RX:
10687       return reloc_type == 1; /* R_RX_DIR32.  */
10688     case EM_S370:
10689       return reloc_type == 1; /* R_I370_ADDR31.  */
10690     case EM_S390_OLD:
10691     case EM_S390:
10692       return reloc_type == 4; /* R_S390_32.  */
10693     case EM_SCORE:
10694       return reloc_type == 8; /* R_SCORE_ABS32.  */
10695     case EM_SH:
10696       return reloc_type == 1; /* R_SH_DIR32.  */
10697     case EM_SPARC32PLUS:
10698     case EM_SPARCV9:
10699     case EM_SPARC:
10700       return reloc_type == 3 /* R_SPARC_32.  */
10701         || reloc_type == 23; /* R_SPARC_UA32.  */
10702     case EM_SPU:
10703       return reloc_type == 6; /* R_SPU_ADDR32 */
10704     case EM_TI_C6000:
10705       return reloc_type == 1; /* R_C6000_ABS32.  */
10706     case EM_TILEGX:
10707       return reloc_type == 2; /* R_TILEGX_32.  */
10708     case EM_TILEPRO:
10709       return reloc_type == 1; /* R_TILEPRO_32.  */
10710     case EM_CYGNUS_V850:
10711     case EM_V850:
10712       return reloc_type == 6; /* R_V850_ABS32.  */
10713     case EM_V800:
10714       return reloc_type == 0x33; /* R_V810_WORD.  */
10715     case EM_VAX:
10716       return reloc_type == 1; /* R_VAX_32.  */
10717     case EM_X86_64:
10718     case EM_L1OM:
10719     case EM_K1OM:
10720       return reloc_type == 10; /* R_X86_64_32.  */
10721     case EM_XC16X:
10722     case EM_C166:
10723       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10724     case EM_XGATE:
10725       return reloc_type == 4; /* R_XGATE_32.  */
10726     case EM_XSTORMY16:
10727       return reloc_type == 1; /* R_XSTROMY16_32.  */
10728     case EM_XTENSA_OLD:
10729     case EM_XTENSA:
10730       return reloc_type == 1; /* R_XTENSA_32.  */
10731     default:
10732       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10733              elf_header.e_machine);
10734       abort ();
10735     }
10736 }
10737
10738 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10739    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10740
10741 static bfd_boolean
10742 is_32bit_pcrel_reloc (unsigned int reloc_type)
10743 {
10744   switch (elf_header.e_machine)
10745     {
10746     case EM_386:
10747     case EM_486:
10748       return reloc_type == 2;  /* R_386_PC32.  */
10749     case EM_68K:
10750       return reloc_type == 4;  /* R_68K_PC32.  */
10751     case EM_AARCH64:
10752       return reloc_type == 261; /* R_AARCH64_PREL32 */
10753     case EM_ADAPTEVA_EPIPHANY:
10754       return reloc_type == 6;
10755     case EM_ALPHA:
10756       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10757     case EM_ARM:
10758       return reloc_type == 3;  /* R_ARM_REL32 */
10759     case EM_MICROBLAZE:
10760       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10761     case EM_OR1K:
10762       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
10763     case EM_PARISC:
10764       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10765     case EM_PPC:
10766       return reloc_type == 26; /* R_PPC_REL32.  */
10767     case EM_PPC64:
10768       return reloc_type == 26; /* R_PPC64_REL32.  */
10769     case EM_S390_OLD:
10770     case EM_S390:
10771       return reloc_type == 5;  /* R_390_PC32.  */
10772     case EM_SH:
10773       return reloc_type == 2;  /* R_SH_REL32.  */
10774     case EM_SPARC32PLUS:
10775     case EM_SPARCV9:
10776     case EM_SPARC:
10777       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10778     case EM_SPU:
10779       return reloc_type == 13; /* R_SPU_REL32.  */
10780     case EM_TILEGX:
10781       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10782     case EM_TILEPRO:
10783       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10784     case EM_X86_64:
10785     case EM_L1OM:
10786     case EM_K1OM:
10787       return reloc_type == 2;  /* R_X86_64_PC32.  */
10788     case EM_XTENSA_OLD:
10789     case EM_XTENSA:
10790       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10791     default:
10792       /* Do not abort or issue an error message here.  Not all targets use
10793          pc-relative 32-bit relocs in their DWARF debug information and we
10794          have already tested for target coverage in is_32bit_abs_reloc.  A
10795          more helpful warning message will be generated by apply_relocations
10796          anyway, so just return.  */
10797       return FALSE;
10798     }
10799 }
10800
10801 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10802    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10803
10804 static bfd_boolean
10805 is_64bit_abs_reloc (unsigned int reloc_type)
10806 {
10807   switch (elf_header.e_machine)
10808     {
10809     case EM_AARCH64:
10810       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10811     case EM_ALPHA:
10812       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10813     case EM_IA_64:
10814       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10815     case EM_PARISC:
10816       return reloc_type == 80; /* R_PARISC_DIR64.  */
10817     case EM_PPC64:
10818       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10819     case EM_SPARC32PLUS:
10820     case EM_SPARCV9:
10821     case EM_SPARC:
10822       return reloc_type == 54; /* R_SPARC_UA64.  */
10823     case EM_X86_64:
10824     case EM_L1OM:
10825     case EM_K1OM:
10826       return reloc_type == 1; /* R_X86_64_64.  */
10827     case EM_S390_OLD:
10828     case EM_S390:
10829       return reloc_type == 22;  /* R_S390_64.  */
10830     case EM_TILEGX:
10831       return reloc_type == 1; /* R_TILEGX_64.  */
10832     case EM_MIPS:
10833       return reloc_type == 18;  /* R_MIPS_64.  */
10834     default:
10835       return FALSE;
10836     }
10837 }
10838
10839 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10840    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10841
10842 static bfd_boolean
10843 is_64bit_pcrel_reloc (unsigned int reloc_type)
10844 {
10845   switch (elf_header.e_machine)
10846     {
10847     case EM_AARCH64:
10848       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10849     case EM_ALPHA:
10850       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10851     case EM_IA_64:
10852       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10853     case EM_PARISC:
10854       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10855     case EM_PPC64:
10856       return reloc_type == 44; /* R_PPC64_REL64.  */
10857     case EM_SPARC32PLUS:
10858     case EM_SPARCV9:
10859     case EM_SPARC:
10860       return reloc_type == 46; /* R_SPARC_DISP64.  */
10861     case EM_X86_64:
10862     case EM_L1OM:
10863     case EM_K1OM:
10864       return reloc_type == 24; /* R_X86_64_PC64.  */
10865     case EM_S390_OLD:
10866     case EM_S390:
10867       return reloc_type == 23;  /* R_S390_PC64.  */
10868     case EM_TILEGX:
10869       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10870     default:
10871       return FALSE;
10872     }
10873 }
10874
10875 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10876    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10877
10878 static bfd_boolean
10879 is_24bit_abs_reloc (unsigned int reloc_type)
10880 {
10881   switch (elf_header.e_machine)
10882     {
10883     case EM_CYGNUS_MN10200:
10884     case EM_MN10200:
10885       return reloc_type == 4; /* R_MN10200_24.  */
10886     default:
10887       return FALSE;
10888     }
10889 }
10890
10891 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10892    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10893
10894 static bfd_boolean
10895 is_16bit_abs_reloc (unsigned int reloc_type)
10896 {
10897   switch (elf_header.e_machine)
10898     {
10899     case EM_AVR_OLD:
10900     case EM_AVR:
10901       return reloc_type == 4; /* R_AVR_16.  */
10902     case EM_ADAPTEVA_EPIPHANY:
10903       return reloc_type == 5;
10904     case EM_CYGNUS_D10V:
10905     case EM_D10V:
10906       return reloc_type == 3; /* R_D10V_16.  */
10907     case EM_H8S:
10908     case EM_H8_300:
10909     case EM_H8_300H:
10910       return reloc_type == R_H8_DIR16;
10911     case EM_IP2K_OLD:
10912     case EM_IP2K:
10913       return reloc_type == 1; /* R_IP2K_16.  */
10914     case EM_M32C_OLD:
10915     case EM_M32C:
10916       return reloc_type == 1; /* R_M32C_16 */
10917     case EM_MSP430:
10918       if (uses_msp430x_relocs ())
10919         return reloc_type == 2; /* R_MSP430_ABS16.  */
10920     case EM_MSP430_OLD:
10921       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10922     case EM_NDS32:
10923       return reloc_type == 19; /* R_NDS32_RELA.  */
10924     case EM_ALTERA_NIOS2:
10925       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10926     case EM_NIOS32:
10927       return reloc_type == 9; /* R_NIOS_16.  */
10928     case EM_OR1K:
10929       return reloc_type == 2; /* R_OR1K_16.  */
10930     case EM_TI_C6000:
10931       return reloc_type == 2; /* R_C6000_ABS16.  */
10932     case EM_XC16X:
10933     case EM_C166:
10934       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10935     case EM_CYGNUS_MN10200:
10936     case EM_MN10200:
10937       return reloc_type == 2; /* R_MN10200_16.  */
10938     case EM_CYGNUS_MN10300:
10939     case EM_MN10300:
10940       return reloc_type == 2; /* R_MN10300_16.  */
10941     case EM_XGATE:
10942       return reloc_type == 3; /* R_XGATE_16.  */
10943     default:
10944       return FALSE;
10945     }
10946 }
10947
10948 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10949    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10950
10951 static bfd_boolean
10952 is_none_reloc (unsigned int reloc_type)
10953 {
10954   switch (elf_header.e_machine)
10955     {
10956     case EM_68K:     /* R_68K_NONE.  */
10957     case EM_386:     /* R_386_NONE.  */
10958     case EM_SPARC32PLUS:
10959     case EM_SPARCV9:
10960     case EM_SPARC:   /* R_SPARC_NONE.  */
10961     case EM_MIPS:    /* R_MIPS_NONE.  */
10962     case EM_PARISC:  /* R_PARISC_NONE.  */
10963     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10964     case EM_ADAPTEVA_EPIPHANY:
10965     case EM_PPC:     /* R_PPC_NONE.  */
10966     case EM_PPC64:   /* R_PPC64_NONE.  */
10967     case EM_ARM:     /* R_ARM_NONE.  */
10968     case EM_IA_64:   /* R_IA64_NONE.  */
10969     case EM_SH:      /* R_SH_NONE.  */
10970     case EM_S390_OLD:
10971     case EM_S390:    /* R_390_NONE.  */
10972     case EM_CRIS:    /* R_CRIS_NONE.  */
10973     case EM_X86_64:  /* R_X86_64_NONE.  */
10974     case EM_L1OM:    /* R_X86_64_NONE.  */
10975     case EM_K1OM:    /* R_X86_64_NONE.  */
10976     case EM_MN10300: /* R_MN10300_NONE.  */
10977     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10978     case EM_M32R:    /* R_M32R_NONE.  */
10979     case EM_TI_C6000:/* R_C6000_NONE.  */
10980     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10981     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10982     case EM_XC16X:
10983     case EM_C166:    /* R_XC16X_NONE.  */
10984     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10985     case EM_NIOS32:  /* R_NIOS_NONE.  */
10986     case EM_OR1K:    /* R_OR1K_NONE. */
10987       return reloc_type == 0;
10988     case EM_AARCH64:
10989       return reloc_type == 0 || reloc_type == 256;
10990     case EM_NDS32:
10991       return (reloc_type == 0       /* R_XTENSA_NONE.  */
10992               || reloc_type == 204  /* R_NDS32_DIFF8.  */
10993               || reloc_type == 205  /* R_NDS32_DIFF16.  */
10994               || reloc_type == 206  /* R_NDS32_DIFF32.  */
10995               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
10996     case EM_XTENSA_OLD:
10997     case EM_XTENSA:
10998       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10999               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11000               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11001               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11002     case EM_METAG:
11003       return reloc_type == 3; /* R_METAG_NONE.  */
11004     }
11005   return FALSE;
11006 }
11007
11008 /* Apply relocations to a section.
11009    Note: So far support has been added only for those relocations
11010    which can be found in debug sections.
11011    FIXME: Add support for more relocations ?  */
11012
11013 static void
11014 apply_relocations (void * file,
11015                    Elf_Internal_Shdr * section,
11016                    unsigned char * start)
11017 {
11018   Elf_Internal_Shdr * relsec;
11019   unsigned char * end = start + section->sh_size;
11020
11021   if (elf_header.e_type != ET_REL)
11022     return;
11023
11024   /* Find the reloc section associated with the section.  */
11025   for (relsec = section_headers;
11026        relsec < section_headers + elf_header.e_shnum;
11027        ++relsec)
11028     {
11029       bfd_boolean is_rela;
11030       unsigned long num_relocs;
11031       Elf_Internal_Rela * relocs;
11032       Elf_Internal_Rela * rp;
11033       Elf_Internal_Shdr * symsec;
11034       Elf_Internal_Sym * symtab;
11035       unsigned long num_syms;
11036       Elf_Internal_Sym * sym;
11037
11038       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11039           || relsec->sh_info >= elf_header.e_shnum
11040           || section_headers + relsec->sh_info != section
11041           || relsec->sh_size == 0
11042           || relsec->sh_link >= elf_header.e_shnum)
11043         continue;
11044
11045       is_rela = relsec->sh_type == SHT_RELA;
11046
11047       if (is_rela)
11048         {
11049           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11050                                   relsec->sh_size, & relocs, & num_relocs))
11051             return;
11052         }
11053       else
11054         {
11055           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11056                                  relsec->sh_size, & relocs, & num_relocs))
11057             return;
11058         }
11059
11060       /* SH uses RELA but uses in place value instead of the addend field.  */
11061       if (elf_header.e_machine == EM_SH)
11062         is_rela = FALSE;
11063
11064       symsec = section_headers + relsec->sh_link;
11065       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11066
11067       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11068         {
11069           bfd_vma         addend;
11070           unsigned int    reloc_type;
11071           unsigned int    reloc_size;
11072           unsigned char * rloc;
11073           unsigned long   sym_index;
11074
11075           reloc_type = get_reloc_type (rp->r_info);
11076
11077           if (target_specific_reloc_handling (rp, start, symtab))
11078             continue;
11079           else if (is_none_reloc (reloc_type))
11080             continue;
11081           else if (is_32bit_abs_reloc (reloc_type)
11082                    || is_32bit_pcrel_reloc (reloc_type))
11083             reloc_size = 4;
11084           else if (is_64bit_abs_reloc (reloc_type)
11085                    || is_64bit_pcrel_reloc (reloc_type))
11086             reloc_size = 8;
11087           else if (is_24bit_abs_reloc (reloc_type))
11088             reloc_size = 3;
11089           else if (is_16bit_abs_reloc (reloc_type))
11090             reloc_size = 2;
11091           else
11092             {
11093               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11094                     reloc_type, printable_section_name (section));
11095               continue;
11096             }
11097
11098           rloc = start + rp->r_offset;
11099           if ((rloc + reloc_size) > end || (rloc < start))
11100             {
11101               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11102                     (unsigned long) rp->r_offset,
11103                     printable_section_name (section));
11104               continue;
11105             }
11106
11107           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11108           if (sym_index >= num_syms)
11109             {
11110               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11111                     sym_index, printable_section_name (section));
11112               continue;
11113             }
11114           sym = symtab + sym_index;
11115
11116           /* If the reloc has a symbol associated with it,
11117              make sure that it is of an appropriate type.
11118
11119              Relocations against symbols without type can happen.
11120              Gcc -feliminate-dwarf2-dups may generate symbols
11121              without type for debug info.
11122
11123              Icc generates relocations against function symbols
11124              instead of local labels.
11125
11126              Relocations against object symbols can happen, eg when
11127              referencing a global array.  For an example of this see
11128              the _clz.o binary in libgcc.a.  */
11129           if (sym != symtab
11130               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11131             {
11132               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11133                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11134                     (long int)(rp - relocs),
11135                     printable_section_name (relsec));
11136               continue;
11137             }
11138
11139           addend = 0;
11140           if (is_rela)
11141             addend += rp->r_addend;
11142           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11143              partial_inplace.  */
11144           if (!is_rela
11145               || (elf_header.e_machine == EM_XTENSA
11146                   && reloc_type == 1)
11147               || ((elf_header.e_machine == EM_PJ
11148                    || elf_header.e_machine == EM_PJ_OLD)
11149                   && reloc_type == 1)
11150               || ((elf_header.e_machine == EM_D30V
11151                    || elf_header.e_machine == EM_CYGNUS_D30V)
11152                   && reloc_type == 12))
11153             addend += byte_get (rloc, reloc_size);
11154
11155           if (is_32bit_pcrel_reloc (reloc_type)
11156               || is_64bit_pcrel_reloc (reloc_type))
11157             {
11158               /* On HPPA, all pc-relative relocations are biased by 8.  */
11159               if (elf_header.e_machine == EM_PARISC)
11160                 addend -= 8;
11161               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11162                         reloc_size);
11163             }
11164           else
11165             byte_put (rloc, addend + sym->st_value, reloc_size);
11166         }
11167
11168       free (symtab);
11169       free (relocs);
11170       break;
11171     }
11172 }
11173
11174 #ifdef SUPPORT_DISASSEMBLY
11175 static int
11176 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11177 {
11178   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11179
11180   /* FIXME: XXX -- to be done --- XXX */
11181
11182   return 1;
11183 }
11184 #endif
11185
11186 /* Reads in the contents of SECTION from FILE, returning a pointer
11187    to a malloc'ed buffer or NULL if something went wrong.  */
11188
11189 static char *
11190 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11191 {
11192   bfd_size_type num_bytes;
11193
11194   num_bytes = section->sh_size;
11195
11196   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11197     {
11198       printf (_("\nSection '%s' has no data to dump.\n"),
11199               printable_section_name (section));
11200       return NULL;
11201     }
11202
11203   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11204                              _("section contents"));
11205 }
11206
11207
11208 static void
11209 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11210 {
11211   Elf_Internal_Shdr * relsec;
11212   bfd_size_type num_bytes;
11213   char * data;
11214   char * end;
11215   char * start;
11216   bfd_boolean some_strings_shown;
11217
11218   start = get_section_contents (section, file);
11219   if (start == NULL)
11220     return;
11221
11222   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11223
11224   /* If the section being dumped has relocations against it the user might
11225      be expecting these relocations to have been applied.  Check for this
11226      case and issue a warning message in order to avoid confusion.
11227      FIXME: Maybe we ought to have an option that dumps a section with
11228      relocs applied ?  */
11229   for (relsec = section_headers;
11230        relsec < section_headers + elf_header.e_shnum;
11231        ++relsec)
11232     {
11233       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11234           || relsec->sh_info >= elf_header.e_shnum
11235           || section_headers + relsec->sh_info != section
11236           || relsec->sh_size == 0
11237           || relsec->sh_link >= elf_header.e_shnum)
11238         continue;
11239
11240       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11241       break;
11242     }
11243
11244   num_bytes = section->sh_size;
11245   data = start;
11246   end  = start + num_bytes;
11247   some_strings_shown = FALSE;
11248
11249   while (data < end)
11250     {
11251       while (!ISPRINT (* data))
11252         if (++ data >= end)
11253           break;
11254
11255       if (data < end)
11256         {
11257 #ifndef __MSVCRT__
11258           /* PR 11128: Use two separate invocations in order to work
11259              around bugs in the Solaris 8 implementation of printf.  */
11260           printf ("  [%6tx]  ", data - start);
11261           printf ("%s\n", data);
11262 #else
11263           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
11264 #endif
11265           data += strlen (data);
11266           some_strings_shown = TRUE;
11267         }
11268     }
11269
11270   if (! some_strings_shown)
11271     printf (_("  No strings found in this section."));
11272
11273   free (start);
11274
11275   putchar ('\n');
11276 }
11277
11278 static void
11279 dump_section_as_bytes (Elf_Internal_Shdr * section,
11280                        FILE * file,
11281                        bfd_boolean relocate)
11282 {
11283   Elf_Internal_Shdr * relsec;
11284   bfd_size_type bytes;
11285   bfd_vma addr;
11286   unsigned char * data;
11287   unsigned char * start;
11288
11289   start = (unsigned char *) get_section_contents (section, file);
11290   if (start == NULL)
11291     return;
11292
11293   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11294
11295   if (relocate)
11296     {
11297       apply_relocations (file, section, start);
11298     }
11299   else
11300     {
11301       /* If the section being dumped has relocations against it the user might
11302          be expecting these relocations to have been applied.  Check for this
11303          case and issue a warning message in order to avoid confusion.
11304          FIXME: Maybe we ought to have an option that dumps a section with
11305          relocs applied ?  */
11306       for (relsec = section_headers;
11307            relsec < section_headers + elf_header.e_shnum;
11308            ++relsec)
11309         {
11310           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11311               || relsec->sh_info >= elf_header.e_shnum
11312               || section_headers + relsec->sh_info != section
11313               || relsec->sh_size == 0
11314               || relsec->sh_link >= elf_header.e_shnum)
11315             continue;
11316
11317           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11318           break;
11319         }
11320     }
11321
11322   addr = section->sh_addr;
11323   bytes = section->sh_size;
11324   data = start;
11325
11326   while (bytes)
11327     {
11328       int j;
11329       int k;
11330       int lbytes;
11331
11332       lbytes = (bytes > 16 ? 16 : bytes);
11333
11334       printf ("  0x%8.8lx ", (unsigned long) addr);
11335
11336       for (j = 0; j < 16; j++)
11337         {
11338           if (j < lbytes)
11339             printf ("%2.2x", data[j]);
11340           else
11341             printf ("  ");
11342
11343           if ((j & 3) == 3)
11344             printf (" ");
11345         }
11346
11347       for (j = 0; j < lbytes; j++)
11348         {
11349           k = data[j];
11350           if (k >= ' ' && k < 0x7f)
11351             printf ("%c", k);
11352           else
11353             printf (".");
11354         }
11355
11356       putchar ('\n');
11357
11358       data  += lbytes;
11359       addr  += lbytes;
11360       bytes -= lbytes;
11361     }
11362
11363   free (start);
11364
11365   putchar ('\n');
11366 }
11367
11368 /* Uncompresses a section that was compressed using zlib, in place.  */
11369
11370 static int
11371 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11372                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11373 {
11374 #ifndef HAVE_ZLIB_H
11375   return FALSE;
11376 #else
11377   dwarf_size_type compressed_size = *size;
11378   unsigned char * compressed_buffer = *buffer;
11379   dwarf_size_type uncompressed_size;
11380   unsigned char * uncompressed_buffer;
11381   z_stream strm;
11382   int rc;
11383   dwarf_size_type header_size = 12;
11384
11385   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11386      by the uncompressed section size, 8 bytes in big-endian order.  */
11387   if (compressed_size < header_size
11388       || ! streq ((char *) compressed_buffer, "ZLIB"))
11389     return 0;
11390
11391   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11392   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11393   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11394   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11395   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11396   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11397   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11398   uncompressed_size += compressed_buffer[11];
11399
11400   /* It is possible the section consists of several compressed
11401      buffers concatenated together, so we uncompress in a loop.  */
11402   strm.zalloc = NULL;
11403   strm.zfree = NULL;
11404   strm.opaque = NULL;
11405   strm.avail_in = compressed_size - header_size;
11406   strm.next_in = (Bytef *) compressed_buffer + header_size;
11407   strm.avail_out = uncompressed_size;
11408   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11409
11410   rc = inflateInit (& strm);
11411   while (strm.avail_in > 0)
11412     {
11413       if (rc != Z_OK)
11414         goto fail;
11415       strm.next_out = ((Bytef *) uncompressed_buffer
11416                        + (uncompressed_size - strm.avail_out));
11417       rc = inflate (&strm, Z_FINISH);
11418       if (rc != Z_STREAM_END)
11419         goto fail;
11420       rc = inflateReset (& strm);
11421     }
11422   rc = inflateEnd (& strm);
11423   if (rc != Z_OK
11424       || strm.avail_out != 0)
11425     goto fail;
11426
11427   free (compressed_buffer);
11428   *buffer = uncompressed_buffer;
11429   *size = uncompressed_size;
11430   return 1;
11431
11432  fail:
11433   free (uncompressed_buffer);
11434   /* Indicate decompression failure.  */
11435   *buffer = NULL;
11436   return 0;
11437 #endif  /* HAVE_ZLIB_H */
11438 }
11439
11440 static int
11441 load_specific_debug_section (enum dwarf_section_display_enum debug,
11442                              Elf_Internal_Shdr * sec, void * file)
11443 {
11444   struct dwarf_section * section = &debug_displays [debug].section;
11445   char buf [64];
11446
11447   /* If it is already loaded, do nothing.  */
11448   if (section->start != NULL)
11449     return 1;
11450
11451   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11452   section->address = sec->sh_addr;
11453   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11454                                                sec->sh_offset, 1,
11455                                                sec->sh_size, buf);
11456   if (section->start == NULL)
11457     section->size = 0;
11458   else
11459     {
11460       section->size = sec->sh_size;
11461       if (uncompress_section_contents (&section->start, &section->size))
11462         sec->sh_size = section->size;
11463     }
11464
11465   if (section->start == NULL)
11466     return 0;
11467
11468   if (debug_displays [debug].relocate)
11469     apply_relocations ((FILE *) file, sec, section->start);
11470
11471   return 1;
11472 }
11473
11474 /* If this is not NULL, load_debug_section will only look for sections
11475    within the list of sections given here.  */
11476 unsigned int *section_subset = NULL;
11477
11478 int
11479 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11480 {
11481   struct dwarf_section * section = &debug_displays [debug].section;
11482   Elf_Internal_Shdr * sec;
11483
11484   /* Locate the debug section.  */
11485   sec = find_section_in_set (section->uncompressed_name, section_subset);
11486   if (sec != NULL)
11487     section->name = section->uncompressed_name;
11488   else
11489     {
11490       sec = find_section_in_set (section->compressed_name, section_subset);
11491       if (sec != NULL)
11492         section->name = section->compressed_name;
11493     }
11494   if (sec == NULL)
11495     return 0;
11496
11497   /* If we're loading from a subset of sections, and we've loaded
11498      a section matching this name before, it's likely that it's a
11499      different one.  */
11500   if (section_subset != NULL)
11501     free_debug_section (debug);
11502
11503   return load_specific_debug_section (debug, sec, (FILE *) file);
11504 }
11505
11506 void
11507 free_debug_section (enum dwarf_section_display_enum debug)
11508 {
11509   struct dwarf_section * section = &debug_displays [debug].section;
11510
11511   if (section->start == NULL)
11512     return;
11513
11514   free ((char *) section->start);
11515   section->start = NULL;
11516   section->address = 0;
11517   section->size = 0;
11518 }
11519
11520 static int
11521 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11522 {
11523   char * name = SECTION_NAME (section);
11524   const char * print_name = printable_section_name (section);
11525   bfd_size_type length;
11526   int result = 1;
11527   int i;
11528
11529   length = section->sh_size;
11530   if (length == 0)
11531     {
11532       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
11533       return 0;
11534     }
11535   if (section->sh_type == SHT_NOBITS)
11536     {
11537       /* There is no point in dumping the contents of a debugging section
11538          which has the NOBITS type - the bits in the file will be random.
11539          This can happen when a file containing a .eh_frame section is
11540          stripped with the --only-keep-debug command line option.  */
11541       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11542               print_name);
11543       return 0;
11544     }
11545
11546   if (const_strneq (name, ".gnu.linkonce.wi."))
11547     name = ".debug_info";
11548
11549   /* See if we know how to display the contents of this section.  */
11550   for (i = 0; i < max; i++)
11551     if (streq (debug_displays[i].section.uncompressed_name, name)
11552         || (i == line && const_strneq (name, ".debug_line."))
11553         || streq (debug_displays[i].section.compressed_name, name))
11554       {
11555         struct dwarf_section * sec = &debug_displays [i].section;
11556         int secondary = (section != find_section (name));
11557
11558         if (secondary)
11559           free_debug_section ((enum dwarf_section_display_enum) i);
11560
11561         if (i == line && const_strneq (name, ".debug_line."))
11562           sec->name = name;
11563         else if (streq (sec->uncompressed_name, name))
11564           sec->name = sec->uncompressed_name;
11565         else
11566           sec->name = sec->compressed_name;
11567         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11568                                          section, file))
11569           {
11570             /* If this debug section is part of a CU/TU set in a .dwp file,
11571                restrict load_debug_section to the sections in that set.  */
11572             section_subset = find_cu_tu_set (file, shndx);
11573
11574             result &= debug_displays[i].display (sec, file);
11575
11576             section_subset = NULL;
11577
11578             if (secondary || (i != info && i != abbrev))
11579               free_debug_section ((enum dwarf_section_display_enum) i);
11580           }
11581
11582         break;
11583       }
11584
11585   if (i == max)
11586     {
11587       printf (_("Unrecognized debug section: %s\n"), print_name);
11588       result = 0;
11589     }
11590
11591   return result;
11592 }
11593
11594 /* Set DUMP_SECTS for all sections where dumps were requested
11595    based on section name.  */
11596
11597 static void
11598 initialise_dumps_byname (void)
11599 {
11600   struct dump_list_entry * cur;
11601
11602   for (cur = dump_sects_byname; cur; cur = cur->next)
11603     {
11604       unsigned int i;
11605       int any;
11606
11607       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11608         if (streq (SECTION_NAME (section_headers + i), cur->name))
11609           {
11610             request_dump_bynumber (i, cur->type);
11611             any = 1;
11612           }
11613
11614       if (!any)
11615         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11616               cur->name);
11617     }
11618 }
11619
11620 static void
11621 process_section_contents (FILE * file)
11622 {
11623   Elf_Internal_Shdr * section;
11624   unsigned int i;
11625
11626   if (! do_dump)
11627     return;
11628
11629   initialise_dumps_byname ();
11630
11631   for (i = 0, section = section_headers;
11632        i < elf_header.e_shnum && i < num_dump_sects;
11633        i++, section++)
11634     {
11635 #ifdef SUPPORT_DISASSEMBLY
11636       if (dump_sects[i] & DISASS_DUMP)
11637         disassemble_section (section, file);
11638 #endif
11639       if (dump_sects[i] & HEX_DUMP)
11640         dump_section_as_bytes (section, file, FALSE);
11641
11642       if (dump_sects[i] & RELOC_DUMP)
11643         dump_section_as_bytes (section, file, TRUE);
11644
11645       if (dump_sects[i] & STRING_DUMP)
11646         dump_section_as_strings (section, file);
11647
11648       if (dump_sects[i] & DEBUG_DUMP)
11649         display_debug_section (i, section, file);
11650     }
11651
11652   /* Check to see if the user requested a
11653      dump of a section that does not exist.  */
11654   while (i++ < num_dump_sects)
11655     if (dump_sects[i])
11656       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11657 }
11658
11659 static void
11660 process_mips_fpe_exception (int mask)
11661 {
11662   if (mask)
11663     {
11664       int first = 1;
11665       if (mask & OEX_FPU_INEX)
11666         fputs ("INEX", stdout), first = 0;
11667       if (mask & OEX_FPU_UFLO)
11668         printf ("%sUFLO", first ? "" : "|"), first = 0;
11669       if (mask & OEX_FPU_OFLO)
11670         printf ("%sOFLO", first ? "" : "|"), first = 0;
11671       if (mask & OEX_FPU_DIV0)
11672         printf ("%sDIV0", first ? "" : "|"), first = 0;
11673       if (mask & OEX_FPU_INVAL)
11674         printf ("%sINVAL", first ? "" : "|");
11675     }
11676   else
11677     fputs ("0", stdout);
11678 }
11679
11680 /* Display's the value of TAG at location P.  If TAG is
11681    greater than 0 it is assumed to be an unknown tag, and
11682    a message is printed to this effect.  Otherwise it is
11683    assumed that a message has already been printed.
11684
11685    If the bottom bit of TAG is set it assumed to have a
11686    string value, otherwise it is assumed to have an integer
11687    value.
11688
11689    Returns an updated P pointing to the first unread byte
11690    beyond the end of TAG's value.
11691
11692    Reads at or beyond END will not be made.  */
11693
11694 static unsigned char *
11695 display_tag_value (int tag,
11696                    unsigned char * p,
11697                    const unsigned char * const end)
11698 {
11699   unsigned long val;
11700
11701   if (tag > 0)
11702     printf ("  Tag_unknown_%d: ", tag);
11703
11704   if (p >= end)
11705     {
11706       warn (_("corrupt tag\n"));
11707     }
11708   else if (tag & 1)
11709     {
11710       /* FIXME: we could read beyond END here.  */
11711       printf ("\"%s\"\n", p);
11712       p += strlen ((char *) p) + 1;
11713     }
11714   else
11715     {
11716       unsigned int len;
11717
11718       val = read_uleb128 (p, &len, end);
11719       p += len;
11720       printf ("%ld (0x%lx)\n", val, val);
11721     }
11722
11723   return p;
11724 }
11725
11726 /* ARM EABI attributes section.  */
11727 typedef struct
11728 {
11729   unsigned int tag;
11730   const char * name;
11731   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11732   unsigned int type;
11733   const char ** table;
11734 } arm_attr_public_tag;
11735
11736 static const char * arm_attr_tag_CPU_arch[] =
11737   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11738    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11739 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11740 static const char * arm_attr_tag_THUMB_ISA_use[] =
11741   {"No", "Thumb-1", "Thumb-2"};
11742 static const char * arm_attr_tag_FP_arch[] =
11743   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11744    "FP for ARMv8"};
11745 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11746 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11747   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11748 static const char * arm_attr_tag_PCS_config[] =
11749   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11750    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11751 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11752   {"V6", "SB", "TLS", "Unused"};
11753 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11754   {"Absolute", "PC-relative", "SB-relative", "None"};
11755 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11756   {"Absolute", "PC-relative", "None"};
11757 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11758   {"None", "direct", "GOT-indirect"};
11759 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11760   {"None", "??? 1", "2", "??? 3", "4"};
11761 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11762 static const char * arm_attr_tag_ABI_FP_denormal[] =
11763   {"Unused", "Needed", "Sign only"};
11764 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11765 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11766 static const char * arm_attr_tag_ABI_FP_number_model[] =
11767   {"Unused", "Finite", "RTABI", "IEEE 754"};
11768 static const char * arm_attr_tag_ABI_enum_size[] =
11769   {"Unused", "small", "int", "forced to int"};
11770 static const char * arm_attr_tag_ABI_HardFP_use[] =
11771   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11772 static const char * arm_attr_tag_ABI_VFP_args[] =
11773   {"AAPCS", "VFP registers", "custom"};
11774 static const char * arm_attr_tag_ABI_WMMX_args[] =
11775   {"AAPCS", "WMMX registers", "custom"};
11776 static const char * arm_attr_tag_ABI_optimization_goals[] =
11777   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11778     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11779 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11780   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11781     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11782 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11783 static const char * arm_attr_tag_FP_HP_extension[] =
11784   {"Not Allowed", "Allowed"};
11785 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11786   {"None", "IEEE 754", "Alternative Format"};
11787 static const char * arm_attr_tag_MPextension_use[] =
11788   {"Not Allowed", "Allowed"};
11789 static const char * arm_attr_tag_DIV_use[] =
11790   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11791     "Allowed in v7-A with integer division extension"};
11792 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11793 static const char * arm_attr_tag_Virtualization_use[] =
11794   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11795     "TrustZone and Virtualization Extensions"};
11796 static const char * arm_attr_tag_MPextension_use_legacy[] =
11797   {"Not Allowed", "Allowed"};
11798
11799 #define LOOKUP(id, name) \
11800   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11801 static arm_attr_public_tag arm_attr_public_tags[] =
11802 {
11803   {4, "CPU_raw_name", 1, NULL},
11804   {5, "CPU_name", 1, NULL},
11805   LOOKUP(6, CPU_arch),
11806   {7, "CPU_arch_profile", 0, NULL},
11807   LOOKUP(8, ARM_ISA_use),
11808   LOOKUP(9, THUMB_ISA_use),
11809   LOOKUP(10, FP_arch),
11810   LOOKUP(11, WMMX_arch),
11811   LOOKUP(12, Advanced_SIMD_arch),
11812   LOOKUP(13, PCS_config),
11813   LOOKUP(14, ABI_PCS_R9_use),
11814   LOOKUP(15, ABI_PCS_RW_data),
11815   LOOKUP(16, ABI_PCS_RO_data),
11816   LOOKUP(17, ABI_PCS_GOT_use),
11817   LOOKUP(18, ABI_PCS_wchar_t),
11818   LOOKUP(19, ABI_FP_rounding),
11819   LOOKUP(20, ABI_FP_denormal),
11820   LOOKUP(21, ABI_FP_exceptions),
11821   LOOKUP(22, ABI_FP_user_exceptions),
11822   LOOKUP(23, ABI_FP_number_model),
11823   {24, "ABI_align_needed", 0, NULL},
11824   {25, "ABI_align_preserved", 0, NULL},
11825   LOOKUP(26, ABI_enum_size),
11826   LOOKUP(27, ABI_HardFP_use),
11827   LOOKUP(28, ABI_VFP_args),
11828   LOOKUP(29, ABI_WMMX_args),
11829   LOOKUP(30, ABI_optimization_goals),
11830   LOOKUP(31, ABI_FP_optimization_goals),
11831   {32, "compatibility", 0, NULL},
11832   LOOKUP(34, CPU_unaligned_access),
11833   LOOKUP(36, FP_HP_extension),
11834   LOOKUP(38, ABI_FP_16bit_format),
11835   LOOKUP(42, MPextension_use),
11836   LOOKUP(44, DIV_use),
11837   {64, "nodefaults", 0, NULL},
11838   {65, "also_compatible_with", 0, NULL},
11839   LOOKUP(66, T2EE_use),
11840   {67, "conformance", 1, NULL},
11841   LOOKUP(68, Virtualization_use),
11842   LOOKUP(70, MPextension_use_legacy)
11843 };
11844 #undef LOOKUP
11845
11846 static unsigned char *
11847 display_arm_attribute (unsigned char * p,
11848                        const unsigned char * const end)
11849 {
11850   unsigned int tag;
11851   unsigned int len;
11852   unsigned int val;
11853   arm_attr_public_tag * attr;
11854   unsigned i;
11855   unsigned int type;
11856
11857   tag = read_uleb128 (p, &len, end);
11858   p += len;
11859   attr = NULL;
11860   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11861     {
11862       if (arm_attr_public_tags[i].tag == tag)
11863         {
11864           attr = &arm_attr_public_tags[i];
11865           break;
11866         }
11867     }
11868
11869   if (attr)
11870     {
11871       printf ("  Tag_%s: ", attr->name);
11872       switch (attr->type)
11873         {
11874         case 0:
11875           switch (tag)
11876             {
11877             case 7: /* Tag_CPU_arch_profile.  */
11878               val = read_uleb128 (p, &len, end);
11879               p += len;
11880               switch (val)
11881                 {
11882                 case 0: printf (_("None\n")); break;
11883                 case 'A': printf (_("Application\n")); break;
11884                 case 'R': printf (_("Realtime\n")); break;
11885                 case 'M': printf (_("Microcontroller\n")); break;
11886                 case 'S': printf (_("Application or Realtime\n")); break;
11887                 default: printf ("??? (%d)\n", val); break;
11888                 }
11889               break;
11890
11891             case 24: /* Tag_align_needed.  */
11892               val = read_uleb128 (p, &len, end);
11893               p += len;
11894               switch (val)
11895                 {
11896                 case 0: printf (_("None\n")); break;
11897                 case 1: printf (_("8-byte\n")); break;
11898                 case 2: printf (_("4-byte\n")); break;
11899                 case 3: printf ("??? 3\n"); break;
11900                 default:
11901                   if (val <= 12)
11902                     printf (_("8-byte and up to %d-byte extended\n"),
11903                             1 << val);
11904                   else
11905                     printf ("??? (%d)\n", val);
11906                   break;
11907                 }
11908               break;
11909
11910             case 25: /* Tag_align_preserved.  */
11911               val = read_uleb128 (p, &len, end);
11912               p += len;
11913               switch (val)
11914                 {
11915                 case 0: printf (_("None\n")); break;
11916                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11917                 case 2: printf (_("8-byte\n")); break;
11918                 case 3: printf ("??? 3\n"); break;
11919                 default:
11920                   if (val <= 12)
11921                     printf (_("8-byte and up to %d-byte extended\n"),
11922                             1 << val);
11923                   else
11924                     printf ("??? (%d)\n", val);
11925                   break;
11926                 }
11927               break;
11928
11929             case 32: /* Tag_compatibility.  */
11930               val = read_uleb128 (p, &len, end);
11931               p += len;
11932               printf (_("flag = %d, vendor = %s\n"), val, p);
11933               p += strlen ((char *) p) + 1;
11934               break;
11935
11936             case 64: /* Tag_nodefaults.  */
11937               p++;
11938               printf (_("True\n"));
11939               break;
11940
11941             case 65: /* Tag_also_compatible_with.  */
11942               val = read_uleb128 (p, &len, end);
11943               p += len;
11944               if (val == 6 /* Tag_CPU_arch.  */)
11945                 {
11946                   val = read_uleb128 (p, &len, end);
11947                   p += len;
11948                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11949                     printf ("??? (%d)\n", val);
11950                   else
11951                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11952                 }
11953               else
11954                 printf ("???\n");
11955               while (*(p++) != '\0' /* NUL terminator.  */);
11956               break;
11957
11958             default:
11959               abort ();
11960             }
11961           return p;
11962
11963         case 1:
11964           return display_tag_value (-1, p, end);
11965         case 2:
11966           return display_tag_value (0, p, end);
11967
11968         default:
11969           assert (attr->type & 0x80);
11970           val = read_uleb128 (p, &len, end);
11971           p += len;
11972           type = attr->type & 0x7f;
11973           if (val >= type)
11974             printf ("??? (%d)\n", val);
11975           else
11976             printf ("%s\n", attr->table[val]);
11977           return p;
11978         }
11979     }
11980
11981   return display_tag_value (tag, p, end);
11982 }
11983
11984 static unsigned char *
11985 display_gnu_attribute (unsigned char * p,
11986                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11987                        const unsigned char * const end)
11988 {
11989   int tag;
11990   unsigned int len;
11991   int val;
11992
11993   tag = read_uleb128 (p, &len, end);
11994   p += len;
11995
11996   /* Tag_compatibility is the only generic GNU attribute defined at
11997      present.  */
11998   if (tag == 32)
11999     {
12000       val = read_uleb128 (p, &len, end);
12001       p += len;
12002       if (p == end)
12003         {
12004           printf (_("flag = %d, vendor = <corrupt>\n"), val);
12005           warn (_("corrupt vendor attribute\n"));
12006         }
12007       else
12008         {
12009           printf (_("flag = %d, vendor = %s\n"), val, p);
12010           p += strlen ((char *) p) + 1;
12011         }
12012       return p;
12013     }
12014
12015   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12016     return display_proc_gnu_attribute (p, tag, end);
12017
12018   return display_tag_value (tag, p, end);
12019 }
12020
12021 static unsigned char *
12022 display_power_gnu_attribute (unsigned char * p,
12023                              int tag,
12024                              const unsigned char * const end)
12025 {
12026   unsigned int len;
12027   int val;
12028
12029   if (tag == Tag_GNU_Power_ABI_FP)
12030     {
12031       val = read_uleb128 (p, &len, end);
12032       p += len;
12033       printf ("  Tag_GNU_Power_ABI_FP: ");
12034
12035       switch (val)
12036         {
12037         case 0:
12038           printf (_("Hard or soft float\n"));
12039           break;
12040         case 1:
12041           printf (_("Hard float\n"));
12042           break;
12043         case 2:
12044           printf (_("Soft float\n"));
12045           break;
12046         case 3:
12047           printf (_("Single-precision hard float\n"));
12048           break;
12049         default:
12050           printf ("??? (%d)\n", val);
12051           break;
12052         }
12053       return p;
12054    }
12055
12056   if (tag == Tag_GNU_Power_ABI_Vector)
12057     {
12058       val = read_uleb128 (p, &len, end);
12059       p += len;
12060       printf ("  Tag_GNU_Power_ABI_Vector: ");
12061       switch (val)
12062         {
12063         case 0:
12064           printf (_("Any\n"));
12065           break;
12066         case 1:
12067           printf (_("Generic\n"));
12068           break;
12069         case 2:
12070           printf ("AltiVec\n");
12071           break;
12072         case 3:
12073           printf ("SPE\n");
12074           break;
12075         default:
12076           printf ("??? (%d)\n", val);
12077           break;
12078         }
12079       return p;
12080    }
12081
12082   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12083     {
12084       if (p == end)
12085         {
12086           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
12087           return p;
12088         }
12089
12090       val = read_uleb128 (p, &len, end);
12091       p += len;
12092       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12093       switch (val)
12094        {
12095        case 0:
12096          printf (_("Any\n"));
12097          break;
12098        case 1:
12099          printf ("r3/r4\n");
12100          break;
12101        case 2:
12102          printf (_("Memory\n"));
12103          break;
12104        default:
12105          printf ("??? (%d)\n", val);
12106          break;
12107        }
12108       return p;
12109     }
12110
12111   return display_tag_value (tag & 1, p, end);
12112 }
12113
12114 static void
12115 display_sparc_hwcaps (int mask)
12116 {
12117   if (mask)
12118     {
12119       int first = 1;
12120       if (mask & ELF_SPARC_HWCAP_MUL32)
12121         fputs ("mul32", stdout), first = 0;
12122       if (mask & ELF_SPARC_HWCAP_DIV32)
12123         printf ("%sdiv32", first ? "" : "|"), first = 0;
12124       if (mask & ELF_SPARC_HWCAP_FSMULD)
12125         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12126       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12127         printf ("%sv8plus", first ? "" : "|"), first = 0;
12128       if (mask & ELF_SPARC_HWCAP_POPC)
12129         printf ("%spopc", first ? "" : "|"), first = 0;
12130       if (mask & ELF_SPARC_HWCAP_VIS)
12131         printf ("%svis", first ? "" : "|"), first = 0;
12132       if (mask & ELF_SPARC_HWCAP_VIS2)
12133         printf ("%svis2", first ? "" : "|"), first = 0;
12134       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12135         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12136       if (mask & ELF_SPARC_HWCAP_FMAF)
12137         printf ("%sfmaf", first ? "" : "|"), first = 0;
12138       if (mask & ELF_SPARC_HWCAP_VIS3)
12139         printf ("%svis3", first ? "" : "|"), first = 0;
12140       if (mask & ELF_SPARC_HWCAP_HPC)
12141         printf ("%shpc", first ? "" : "|"), first = 0;
12142       if (mask & ELF_SPARC_HWCAP_RANDOM)
12143         printf ("%srandom", first ? "" : "|"), first = 0;
12144       if (mask & ELF_SPARC_HWCAP_TRANS)
12145         printf ("%strans", first ? "" : "|"), first = 0;
12146       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12147         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12148       if (mask & ELF_SPARC_HWCAP_IMA)
12149         printf ("%sima", first ? "" : "|"), first = 0;
12150       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12151         printf ("%scspare", first ? "" : "|"), first = 0;
12152     }
12153   else
12154     fputc('0', stdout);
12155   fputc('\n', stdout);
12156 }
12157
12158 static void
12159 display_sparc_hwcaps2 (int mask)
12160 {
12161   if (mask)
12162     {
12163       int first = 1;
12164       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12165         fputs ("fjathplus", stdout), first = 0;
12166       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12167         printf ("%svis3b", first ? "" : "|"), first = 0;
12168       if (mask & ELF_SPARC_HWCAP2_ADP)
12169         printf ("%sadp", first ? "" : "|"), first = 0;
12170       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12171         printf ("%ssparc5", first ? "" : "|"), first = 0;
12172       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12173         printf ("%smwait", first ? "" : "|"), first = 0;
12174       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12175         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12176       if (mask & ELF_SPARC_HWCAP2_XMONT)
12177         printf ("%sxmont2", first ? "" : "|"), first = 0;
12178       if (mask & ELF_SPARC_HWCAP2_NSEC)
12179         printf ("%snsec", first ? "" : "|"), first = 0;
12180       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12181         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12182       if (mask & ELF_SPARC_HWCAP2_FJDES)
12183         printf ("%sfjdes", first ? "" : "|"), first = 0;
12184       if (mask & ELF_SPARC_HWCAP2_FJAES)
12185         printf ("%sfjaes", first ? "" : "|"), first = 0;
12186     }
12187   else
12188     fputc('0', stdout);
12189   fputc('\n', stdout);
12190 }
12191
12192 static unsigned char *
12193 display_sparc_gnu_attribute (unsigned char * p,
12194                              int tag,
12195                              const unsigned char * const end)
12196 {
12197   unsigned int len;
12198   int val;
12199
12200   if (tag == Tag_GNU_Sparc_HWCAPS)
12201     {
12202       val = read_uleb128 (p, &len, end);
12203       p += len;
12204       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12205       display_sparc_hwcaps (val);
12206       return p;
12207     }
12208   if (tag == Tag_GNU_Sparc_HWCAPS2)
12209     {
12210       val = read_uleb128 (p, &len, end);
12211       p += len;
12212       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12213       display_sparc_hwcaps2 (val);
12214       return p;
12215     }
12216
12217   return display_tag_value (tag, p, end);
12218 }
12219
12220 static void
12221 print_mips_fp_abi_value (int val)
12222 {
12223   switch (val)
12224     {
12225     case Val_GNU_MIPS_ABI_FP_ANY:
12226       printf (_("Hard or soft float\n"));
12227       break;
12228     case Val_GNU_MIPS_ABI_FP_DOUBLE:
12229       printf (_("Hard float (double precision)\n"));
12230       break;
12231     case Val_GNU_MIPS_ABI_FP_SINGLE:
12232       printf (_("Hard float (single precision)\n"));
12233       break;
12234     case Val_GNU_MIPS_ABI_FP_SOFT:
12235       printf (_("Soft float\n"));
12236       break;
12237     case Val_GNU_MIPS_ABI_FP_OLD_64:
12238       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12239       break;
12240     case Val_GNU_MIPS_ABI_FP_XX:
12241       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12242       break;
12243     case Val_GNU_MIPS_ABI_FP_64:
12244       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12245       break;
12246     case Val_GNU_MIPS_ABI_FP_64A:
12247       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12248       break;
12249     default:
12250       printf ("??? (%d)\n", val);
12251       break;
12252     }
12253 }
12254
12255 static unsigned char *
12256 display_mips_gnu_attribute (unsigned char * p,
12257                             int tag,
12258                             const unsigned char * const end)
12259 {
12260   if (tag == Tag_GNU_MIPS_ABI_FP)
12261     {
12262       unsigned int len;
12263       int val;
12264
12265       val = read_uleb128 (p, &len, end);
12266       p += len;
12267       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12268
12269       print_mips_fp_abi_value (val);
12270
12271       return p;
12272    }
12273
12274   if (tag == Tag_GNU_MIPS_ABI_MSA)
12275     {
12276       unsigned int len;
12277       int val;
12278
12279       val = read_uleb128 (p, &len, end);
12280       p += len;
12281       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12282
12283       switch (val)
12284         {
12285         case Val_GNU_MIPS_ABI_MSA_ANY:
12286           printf (_("Any MSA or not\n"));
12287           break;
12288         case Val_GNU_MIPS_ABI_MSA_128:
12289           printf (_("128-bit MSA\n"));
12290           break;
12291         default:
12292           printf ("??? (%d)\n", val);
12293           break;
12294         }
12295       return p;
12296     }
12297
12298   return display_tag_value (tag & 1, p, end);
12299 }
12300
12301 static unsigned char *
12302 display_tic6x_attribute (unsigned char * p,
12303                          const unsigned char * const end)
12304 {
12305   int tag;
12306   unsigned int len;
12307   int val;
12308
12309   tag = read_uleb128 (p, &len, end);
12310   p += len;
12311
12312   switch (tag)
12313     {
12314     case Tag_ISA:
12315       val = read_uleb128 (p, &len, end);
12316       p += len;
12317       printf ("  Tag_ISA: ");
12318
12319       switch (val)
12320         {
12321         case C6XABI_Tag_ISA_none:
12322           printf (_("None\n"));
12323           break;
12324         case C6XABI_Tag_ISA_C62X:
12325           printf ("C62x\n");
12326           break;
12327         case C6XABI_Tag_ISA_C67X:
12328           printf ("C67x\n");
12329           break;
12330         case C6XABI_Tag_ISA_C67XP:
12331           printf ("C67x+\n");
12332           break;
12333         case C6XABI_Tag_ISA_C64X:
12334           printf ("C64x\n");
12335           break;
12336         case C6XABI_Tag_ISA_C64XP:
12337           printf ("C64x+\n");
12338           break;
12339         case C6XABI_Tag_ISA_C674X:
12340           printf ("C674x\n");
12341           break;
12342         default:
12343           printf ("??? (%d)\n", val);
12344           break;
12345         }
12346       return p;
12347
12348     case Tag_ABI_wchar_t:
12349       val = read_uleb128 (p, &len, end);
12350       p += len;
12351       printf ("  Tag_ABI_wchar_t: ");
12352       switch (val)
12353         {
12354         case 0:
12355           printf (_("Not used\n"));
12356           break;
12357         case 1:
12358           printf (_("2 bytes\n"));
12359           break;
12360         case 2:
12361           printf (_("4 bytes\n"));
12362           break;
12363         default:
12364           printf ("??? (%d)\n", val);
12365           break;
12366         }
12367       return p;
12368
12369     case Tag_ABI_stack_align_needed:
12370       val = read_uleb128 (p, &len, end);
12371       p += len;
12372       printf ("  Tag_ABI_stack_align_needed: ");
12373       switch (val)
12374         {
12375         case 0:
12376           printf (_("8-byte\n"));
12377           break;
12378         case 1:
12379           printf (_("16-byte\n"));
12380           break;
12381         default:
12382           printf ("??? (%d)\n", val);
12383           break;
12384         }
12385       return p;
12386
12387     case Tag_ABI_stack_align_preserved:
12388       val = read_uleb128 (p, &len, end);
12389       p += len;
12390       printf ("  Tag_ABI_stack_align_preserved: ");
12391       switch (val)
12392         {
12393         case 0:
12394           printf (_("8-byte\n"));
12395           break;
12396         case 1:
12397           printf (_("16-byte\n"));
12398           break;
12399         default:
12400           printf ("??? (%d)\n", val);
12401           break;
12402         }
12403       return p;
12404
12405     case Tag_ABI_DSBT:
12406       val = read_uleb128 (p, &len, end);
12407       p += len;
12408       printf ("  Tag_ABI_DSBT: ");
12409       switch (val)
12410         {
12411         case 0:
12412           printf (_("DSBT addressing not used\n"));
12413           break;
12414         case 1:
12415           printf (_("DSBT addressing used\n"));
12416           break;
12417         default:
12418           printf ("??? (%d)\n", val);
12419           break;
12420         }
12421       return p;
12422
12423     case Tag_ABI_PID:
12424       val = read_uleb128 (p, &len, end);
12425       p += len;
12426       printf ("  Tag_ABI_PID: ");
12427       switch (val)
12428         {
12429         case 0:
12430           printf (_("Data addressing position-dependent\n"));
12431           break;
12432         case 1:
12433           printf (_("Data addressing position-independent, GOT near DP\n"));
12434           break;
12435         case 2:
12436           printf (_("Data addressing position-independent, GOT far from DP\n"));
12437           break;
12438         default:
12439           printf ("??? (%d)\n", val);
12440           break;
12441         }
12442       return p;
12443
12444     case Tag_ABI_PIC:
12445       val = read_uleb128 (p, &len, end);
12446       p += len;
12447       printf ("  Tag_ABI_PIC: ");
12448       switch (val)
12449         {
12450         case 0:
12451           printf (_("Code addressing position-dependent\n"));
12452           break;
12453         case 1:
12454           printf (_("Code addressing position-independent\n"));
12455           break;
12456         default:
12457           printf ("??? (%d)\n", val);
12458           break;
12459         }
12460       return p;
12461
12462     case Tag_ABI_array_object_alignment:
12463       val = read_uleb128 (p, &len, end);
12464       p += len;
12465       printf ("  Tag_ABI_array_object_alignment: ");
12466       switch (val)
12467         {
12468         case 0:
12469           printf (_("8-byte\n"));
12470           break;
12471         case 1:
12472           printf (_("4-byte\n"));
12473           break;
12474         case 2:
12475           printf (_("16-byte\n"));
12476           break;
12477         default:
12478           printf ("??? (%d)\n", val);
12479           break;
12480         }
12481       return p;
12482
12483     case Tag_ABI_array_object_align_expected:
12484       val = read_uleb128 (p, &len, end);
12485       p += len;
12486       printf ("  Tag_ABI_array_object_align_expected: ");
12487       switch (val)
12488         {
12489         case 0:
12490           printf (_("8-byte\n"));
12491           break;
12492         case 1:
12493           printf (_("4-byte\n"));
12494           break;
12495         case 2:
12496           printf (_("16-byte\n"));
12497           break;
12498         default:
12499           printf ("??? (%d)\n", val);
12500           break;
12501         }
12502       return p;
12503
12504     case Tag_ABI_compatibility:
12505       val = read_uleb128 (p, &len, end);
12506       p += len;
12507       printf ("  Tag_ABI_compatibility: ");
12508       printf (_("flag = %d, vendor = %s\n"), val, p);
12509       p += strlen ((char *) p) + 1;
12510       return p;
12511
12512     case Tag_ABI_conformance:
12513       printf ("  Tag_ABI_conformance: ");
12514       printf ("\"%s\"\n", p);
12515       p += strlen ((char *) p) + 1;
12516       return p;
12517     }
12518
12519   return display_tag_value (tag, p, end);
12520 }
12521
12522 static void
12523 display_raw_attribute (unsigned char * p, unsigned char * end)
12524 {
12525   unsigned long addr = 0;
12526   size_t bytes = end - p;
12527
12528   assert (end > p);
12529   while (bytes)
12530     {
12531       int j;
12532       int k;
12533       int lbytes = (bytes > 16 ? 16 : bytes);
12534
12535       printf ("  0x%8.8lx ", addr);
12536
12537       for (j = 0; j < 16; j++)
12538         {
12539           if (j < lbytes)
12540             printf ("%2.2x", p[j]);
12541           else
12542             printf ("  ");
12543
12544           if ((j & 3) == 3)
12545             printf (" ");
12546         }
12547
12548       for (j = 0; j < lbytes; j++)
12549         {
12550           k = p[j];
12551           if (k >= ' ' && k < 0x7f)
12552             printf ("%c", k);
12553           else
12554             printf (".");
12555         }
12556
12557       putchar ('\n');
12558
12559       p  += lbytes;
12560       bytes -= lbytes;
12561       addr += lbytes;
12562     }
12563
12564   putchar ('\n');
12565 }
12566
12567 static unsigned char *
12568 display_msp430x_attribute (unsigned char * p,
12569                            const unsigned char * const end)
12570 {
12571   unsigned int len;
12572   int val;
12573   int tag;
12574
12575   tag = read_uleb128 (p, & len, end);
12576   p += len;
12577
12578   switch (tag)
12579     {
12580     case OFBA_MSPABI_Tag_ISA:
12581       val = read_uleb128 (p, &len, end);
12582       p += len;
12583       printf ("  Tag_ISA: ");
12584       switch (val)
12585         {
12586         case 0: printf (_("None\n")); break;
12587         case 1: printf (_("MSP430\n")); break;
12588         case 2: printf (_("MSP430X\n")); break;
12589         default: printf ("??? (%d)\n", val); break;
12590         }
12591       break;
12592
12593     case OFBA_MSPABI_Tag_Code_Model:
12594       val = read_uleb128 (p, &len, end);
12595       p += len;
12596       printf ("  Tag_Code_Model: ");
12597       switch (val)
12598         {
12599         case 0: printf (_("None\n")); break;
12600         case 1: printf (_("Small\n")); break;
12601         case 2: printf (_("Large\n")); break;
12602         default: printf ("??? (%d)\n", val); break;
12603         }
12604       break;
12605
12606     case OFBA_MSPABI_Tag_Data_Model:
12607       val = read_uleb128 (p, &len, end);
12608       p += len;
12609       printf ("  Tag_Data_Model: ");
12610       switch (val)
12611         {
12612         case 0: printf (_("None\n")); break;
12613         case 1: printf (_("Small\n")); break;
12614         case 2: printf (_("Large\n")); break;
12615         case 3: printf (_("Restricted Large\n")); break;
12616         default: printf ("??? (%d)\n", val); break;
12617         }
12618       break;
12619
12620     default:
12621       printf (_("  <unknown tag %d>: "), tag);
12622
12623       if (tag & 1)
12624         {
12625           printf ("\"%s\"\n", p);
12626           p += strlen ((char *) p) + 1;
12627         }
12628       else
12629         {
12630           val = read_uleb128 (p, &len, end);
12631           p += len;
12632           printf ("%d (0x%x)\n", val, val);
12633         }
12634       break;
12635    }
12636
12637   return p;
12638 }
12639
12640 static int
12641 process_attributes (FILE * file,
12642                     const char * public_name,
12643                     unsigned int proc_type,
12644                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12645                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12646 {
12647   Elf_Internal_Shdr * sect;
12648   unsigned char * contents;
12649   unsigned char * p;
12650   unsigned char * end;
12651   bfd_vma section_len;
12652   bfd_vma len;
12653   unsigned i;
12654
12655   /* Find the section header so that we get the size.  */
12656   for (i = 0, sect = section_headers;
12657        i < elf_header.e_shnum;
12658        i++, sect++)
12659     {
12660       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12661         continue;
12662
12663       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12664                                              sect->sh_size, _("attributes"));
12665       if (contents == NULL)
12666         continue;
12667
12668       p = contents;
12669       if (*p == 'A')
12670         {
12671           len = sect->sh_size - 1;
12672           p++;
12673
12674           while (len > 0)
12675             {
12676               unsigned int namelen;
12677               bfd_boolean public_section;
12678               bfd_boolean gnu_section;
12679
12680               if (len <= 4)
12681                 {
12682                   error (_("Tag section ends prematurely\n"));
12683                   break;
12684                 }
12685               section_len = byte_get (p, 4);
12686               p += 4;
12687
12688               if (section_len > len)
12689                 {
12690                   error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12691                           (unsigned) section_len, (unsigned) len);
12692                   section_len = len;
12693                 }
12694               /* PR 17531: file: 001-101425-0.004  */
12695               else if (section_len < 5)
12696                 {
12697                   error (_("Attribute length of %u is too small\n"), (unsigned) section_len);
12698                   break;
12699                 }
12700
12701               len -= section_len;
12702               section_len -= 4;
12703
12704               namelen = strnlen ((char *) p, section_len) + 1;
12705               if (namelen == 0 || namelen >= section_len)
12706                 {
12707                   error (_("Corrupt attribute section name\n"));
12708                   break;
12709                 }
12710
12711               printf (_("Attribute Section: %s\n"), p);
12712
12713               if (public_name && streq ((char *) p, public_name))
12714                 public_section = TRUE;
12715               else
12716                 public_section = FALSE;
12717
12718               if (streq ((char *) p, "gnu"))
12719                 gnu_section = TRUE;
12720               else
12721                 gnu_section = FALSE;
12722
12723               p += namelen;
12724               section_len -= namelen;
12725
12726               while (section_len > 0)
12727                 {
12728                   int tag;
12729                   int val;
12730                   bfd_vma size;
12731
12732                   /* PR binutils/17531: Safe handling of corrupt files.  */
12733                   if (section_len < 6)
12734                     {
12735                       error (_("Unused bytes at end of section\n"));
12736                       section_len = 0;
12737                       break;
12738                     }
12739
12740                   tag = *(p++);
12741                   size = byte_get (p, 4);
12742                   if (size > section_len)
12743                     {
12744                       error (_("Bad subsection length (%u > %u)\n"),
12745                               (unsigned) size, (unsigned) section_len);
12746                       size = section_len;
12747                     }
12748                   /* PR binutils/17531: Safe handling of corrupt files.  */
12749                   if (size < 6)
12750                     {
12751                       error (_("Bad subsection length (%u < 6)\n"),
12752                               (unsigned) size);
12753                       section_len = 0;
12754                       break;
12755                     }
12756
12757                   section_len -= size;
12758                   end = p + size - 1;
12759                   p += 4;
12760
12761                   switch (tag)
12762                     {
12763                     case 1:
12764                       printf (_("File Attributes\n"));
12765                       break;
12766                     case 2:
12767                       printf (_("Section Attributes:"));
12768                       goto do_numlist;
12769                     case 3:
12770                       printf (_("Symbol Attributes:"));
12771                     do_numlist:
12772                       for (;;)
12773                         {
12774                           unsigned int j;
12775
12776                           val = read_uleb128 (p, &j, end);
12777                           p += j;
12778                           if (val == 0)
12779                             break;
12780                           printf (" %d", val);
12781                         }
12782                       printf ("\n");
12783                       break;
12784                     default:
12785                       printf (_("Unknown tag: %d\n"), tag);
12786                       public_section = FALSE;
12787                       break;
12788                     }
12789
12790                   if (public_section)
12791                     {
12792                       while (p < end)
12793                         p = display_pub_attribute (p, end);
12794                     }
12795                   else if (gnu_section)
12796                     {
12797                       while (p < end)
12798                         p = display_gnu_attribute (p,
12799                                                    display_proc_gnu_attribute,
12800                                                    end);
12801                     }
12802                   else
12803                     {
12804                       printf (_("  Unknown section contexts\n"));
12805                       display_raw_attribute (p, end);
12806                       p = end;
12807                     }
12808                 }
12809             }
12810         }
12811       else
12812         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
12813
12814       free (contents);
12815     }
12816   return 1;
12817 }
12818
12819 static int
12820 process_arm_specific (FILE * file)
12821 {
12822   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12823                              display_arm_attribute, NULL);
12824 }
12825
12826 static int
12827 process_power_specific (FILE * file)
12828 {
12829   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12830                              display_power_gnu_attribute);
12831 }
12832
12833 static int
12834 process_sparc_specific (FILE * file)
12835 {
12836   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12837                              display_sparc_gnu_attribute);
12838 }
12839
12840 static int
12841 process_tic6x_specific (FILE * file)
12842 {
12843   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12844                              display_tic6x_attribute, NULL);
12845 }
12846
12847 static int
12848 process_msp430x_specific (FILE * file)
12849 {
12850   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12851                              display_msp430x_attribute, NULL);
12852 }
12853
12854 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12855    Print the Address, Access and Initial fields of an entry at VMA ADDR
12856    and return the VMA of the next entry.  */
12857
12858 static bfd_vma
12859 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12860 {
12861   printf ("  ");
12862   print_vma (addr, LONG_HEX);
12863   printf (" ");
12864   if (addr < pltgot + 0xfff0)
12865     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12866   else
12867     printf ("%10s", "");
12868   printf (" ");
12869   if (data == NULL)
12870     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12871   else
12872     {
12873       bfd_vma entry;
12874
12875       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12876       print_vma (entry, LONG_HEX);
12877     }
12878   return addr + (is_32bit_elf ? 4 : 8);
12879 }
12880
12881 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12882    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12883    ADDR and return the VMA of the next entry.  */
12884
12885 static bfd_vma
12886 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12887 {
12888   printf ("  ");
12889   print_vma (addr, LONG_HEX);
12890   printf (" ");
12891   if (data == NULL)
12892     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12893   else
12894     {
12895       bfd_vma entry;
12896
12897       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12898       print_vma (entry, LONG_HEX);
12899     }
12900   return addr + (is_32bit_elf ? 4 : 8);
12901 }
12902
12903 static void
12904 print_mips_ases (unsigned int mask)
12905 {
12906   if (mask & AFL_ASE_DSP)
12907     fputs ("\n\tDSP ASE", stdout);
12908   if (mask & AFL_ASE_DSPR2)
12909     fputs ("\n\tDSP R2 ASE", stdout);
12910   if (mask & AFL_ASE_EVA)
12911     fputs ("\n\tEnhanced VA Scheme", stdout);
12912   if (mask & AFL_ASE_MCU)
12913     fputs ("\n\tMCU (MicroController) ASE", stdout);
12914   if (mask & AFL_ASE_MDMX)
12915     fputs ("\n\tMDMX ASE", stdout);
12916   if (mask & AFL_ASE_MIPS3D)
12917     fputs ("\n\tMIPS-3D ASE", stdout);
12918   if (mask & AFL_ASE_MT)
12919     fputs ("\n\tMT ASE", stdout);
12920   if (mask & AFL_ASE_SMARTMIPS)
12921     fputs ("\n\tSmartMIPS ASE", stdout);
12922   if (mask & AFL_ASE_VIRT)
12923     fputs ("\n\tVZ ASE", stdout);
12924   if (mask & AFL_ASE_MSA)
12925     fputs ("\n\tMSA ASE", stdout);
12926   if (mask & AFL_ASE_MIPS16)
12927     fputs ("\n\tMIPS16 ASE", stdout);
12928   if (mask & AFL_ASE_MICROMIPS)
12929     fputs ("\n\tMICROMIPS ASE", stdout);
12930   if (mask & AFL_ASE_XPA)
12931     fputs ("\n\tXPA ASE", stdout);
12932   if (mask == 0)
12933     fprintf (stdout, "\n\t%s", _("None"));
12934   else if ((mask & ~AFL_ASE_MASK) != 0)
12935     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
12936 }
12937
12938 static void
12939 print_mips_isa_ext (unsigned int isa_ext)
12940 {
12941   switch (isa_ext)
12942     {
12943     case 0:
12944       fputs (_("None"), stdout);
12945       break;
12946     case AFL_EXT_XLR:
12947       fputs ("RMI XLR", stdout);
12948       break;
12949     case AFL_EXT_OCTEON3:
12950       fputs ("Cavium Networks Octeon3", stdout);
12951       break;
12952     case AFL_EXT_OCTEON2:
12953       fputs ("Cavium Networks Octeon2", stdout);
12954       break;
12955     case AFL_EXT_OCTEONP:
12956       fputs ("Cavium Networks OcteonP", stdout);
12957       break;
12958     case AFL_EXT_LOONGSON_3A:
12959       fputs ("Loongson 3A", stdout);
12960       break;
12961     case AFL_EXT_OCTEON:
12962       fputs ("Cavium Networks Octeon", stdout);
12963       break;
12964     case AFL_EXT_5900:
12965       fputs ("Toshiba R5900", stdout);
12966       break;
12967     case AFL_EXT_4650:
12968       fputs ("MIPS R4650", stdout);
12969       break;
12970     case AFL_EXT_4010:
12971       fputs ("LSI R4010", stdout);
12972       break;
12973     case AFL_EXT_4100:
12974       fputs ("NEC VR4100", stdout);
12975       break;
12976     case AFL_EXT_3900:
12977       fputs ("Toshiba R3900", stdout);
12978       break;
12979     case AFL_EXT_10000:
12980       fputs ("MIPS R10000", stdout);
12981       break;
12982     case AFL_EXT_SB1:
12983       fputs ("Broadcom SB-1", stdout);
12984       break;
12985     case AFL_EXT_4111:
12986       fputs ("NEC VR4111/VR4181", stdout);
12987       break;
12988     case AFL_EXT_4120:
12989       fputs ("NEC VR4120", stdout);
12990       break;
12991     case AFL_EXT_5400:
12992       fputs ("NEC VR5400", stdout);
12993       break;
12994     case AFL_EXT_5500:
12995       fputs ("NEC VR5500", stdout);
12996       break;
12997     case AFL_EXT_LOONGSON_2E:
12998       fputs ("ST Microelectronics Loongson 2E", stdout);
12999       break;
13000     case AFL_EXT_LOONGSON_2F:
13001       fputs ("ST Microelectronics Loongson 2F", stdout);
13002       break;
13003     default:
13004       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13005     }
13006 }
13007
13008 static int
13009 get_mips_reg_size (int reg_size)
13010 {
13011   return (reg_size == AFL_REG_NONE) ? 0
13012          : (reg_size == AFL_REG_32) ? 32
13013          : (reg_size == AFL_REG_64) ? 64
13014          : (reg_size == AFL_REG_128) ? 128
13015          : -1;
13016 }
13017
13018 static int
13019 process_mips_specific (FILE * file)
13020 {
13021   Elf_Internal_Dyn * entry;
13022   Elf_Internal_Shdr *sect = NULL;
13023   size_t liblist_offset = 0;
13024   size_t liblistno = 0;
13025   size_t conflictsno = 0;
13026   size_t options_offset = 0;
13027   size_t conflicts_offset = 0;
13028   size_t pltrelsz = 0;
13029   size_t pltrel = 0;
13030   bfd_vma pltgot = 0;
13031   bfd_vma mips_pltgot = 0;
13032   bfd_vma jmprel = 0;
13033   bfd_vma local_gotno = 0;
13034   bfd_vma gotsym = 0;
13035   bfd_vma symtabno = 0;
13036
13037   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13038                       display_mips_gnu_attribute);
13039
13040   sect = find_section (".MIPS.abiflags");
13041
13042   if (sect != NULL)
13043     {
13044       Elf_External_ABIFlags_v0 *abiflags_ext;
13045       Elf_Internal_ABIFlags_v0 abiflags_in;
13046
13047       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13048         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13049       else
13050         {
13051           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13052                                    sect->sh_size, _("MIPS ABI Flags section"));
13053           if (abiflags_ext)
13054             {
13055               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13056               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13057               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13058               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13059               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13060               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13061               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13062               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13063               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13064               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13065               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13066
13067               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13068               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13069               if (abiflags_in.isa_rev > 1)
13070                 printf ("r%d", abiflags_in.isa_rev);
13071               printf ("\nGPR size: %d",
13072                       get_mips_reg_size (abiflags_in.gpr_size));
13073               printf ("\nCPR1 size: %d",
13074                       get_mips_reg_size (abiflags_in.cpr1_size));
13075               printf ("\nCPR2 size: %d",
13076                       get_mips_reg_size (abiflags_in.cpr2_size));
13077               fputs ("\nFP ABI: ", stdout);
13078               print_mips_fp_abi_value (abiflags_in.fp_abi);
13079               fputs ("ISA Extension: ", stdout);
13080               print_mips_isa_ext (abiflags_in.isa_ext);
13081               fputs ("\nASEs:", stdout);
13082               print_mips_ases (abiflags_in.ases);
13083               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13084               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13085               fputc ('\n', stdout);
13086               free (abiflags_ext);
13087             }
13088         }
13089     }
13090
13091   /* We have a lot of special sections.  Thanks SGI!  */
13092   if (dynamic_section == NULL)
13093     /* No information available.  */
13094     return 0;
13095
13096   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
13097     switch (entry->d_tag)
13098       {
13099       case DT_MIPS_LIBLIST:
13100         liblist_offset
13101           = offset_from_vma (file, entry->d_un.d_val,
13102                              liblistno * sizeof (Elf32_External_Lib));
13103         break;
13104       case DT_MIPS_LIBLISTNO:
13105         liblistno = entry->d_un.d_val;
13106         break;
13107       case DT_MIPS_OPTIONS:
13108         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13109         break;
13110       case DT_MIPS_CONFLICT:
13111         conflicts_offset
13112           = offset_from_vma (file, entry->d_un.d_val,
13113                              conflictsno * sizeof (Elf32_External_Conflict));
13114         break;
13115       case DT_MIPS_CONFLICTNO:
13116         conflictsno = entry->d_un.d_val;
13117         break;
13118       case DT_PLTGOT:
13119         pltgot = entry->d_un.d_ptr;
13120         break;
13121       case DT_MIPS_LOCAL_GOTNO:
13122         local_gotno = entry->d_un.d_val;
13123         break;
13124       case DT_MIPS_GOTSYM:
13125         gotsym = entry->d_un.d_val;
13126         break;
13127       case DT_MIPS_SYMTABNO:
13128         symtabno = entry->d_un.d_val;
13129         break;
13130       case DT_MIPS_PLTGOT:
13131         mips_pltgot = entry->d_un.d_ptr;
13132         break;
13133       case DT_PLTREL:
13134         pltrel = entry->d_un.d_val;
13135         break;
13136       case DT_PLTRELSZ:
13137         pltrelsz = entry->d_un.d_val;
13138         break;
13139       case DT_JMPREL:
13140         jmprel = entry->d_un.d_ptr;
13141         break;
13142       default:
13143         break;
13144       }
13145
13146   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13147     {
13148       Elf32_External_Lib * elib;
13149       size_t cnt;
13150
13151       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13152                                               liblistno,
13153                                               sizeof (Elf32_External_Lib),
13154                                               _("liblist section data"));
13155       if (elib)
13156         {
13157           printf (_("\nSection '.liblist' contains %lu entries:\n"),
13158                   (unsigned long) liblistno);
13159           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
13160                  stdout);
13161
13162           for (cnt = 0; cnt < liblistno; ++cnt)
13163             {
13164               Elf32_Lib liblist;
13165               time_t atime;
13166               char timebuf[20];
13167               struct tm * tmp;
13168
13169               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13170               atime = BYTE_GET (elib[cnt].l_time_stamp);
13171               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13172               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13173               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13174
13175               tmp = gmtime (&atime);
13176               snprintf (timebuf, sizeof (timebuf),
13177                         "%04u-%02u-%02uT%02u:%02u:%02u",
13178                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13179                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13180
13181               printf ("%3lu: ", (unsigned long) cnt);
13182               if (VALID_DYNAMIC_NAME (liblist.l_name))
13183                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13184               else
13185                 printf (_("<corrupt: %9ld>"), liblist.l_name);
13186               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13187                       liblist.l_version);
13188
13189               if (liblist.l_flags == 0)
13190                 puts (_(" NONE"));
13191               else
13192                 {
13193                   static const struct
13194                   {
13195                     const char * name;
13196                     int bit;
13197                   }
13198                   l_flags_vals[] =
13199                   {
13200                     { " EXACT_MATCH", LL_EXACT_MATCH },
13201                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13202                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13203                     { " EXPORTS", LL_EXPORTS },
13204                     { " DELAY_LOAD", LL_DELAY_LOAD },
13205                     { " DELTA", LL_DELTA }
13206                   };
13207                   int flags = liblist.l_flags;
13208                   size_t fcnt;
13209
13210                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13211                     if ((flags & l_flags_vals[fcnt].bit) != 0)
13212                       {
13213                         fputs (l_flags_vals[fcnt].name, stdout);
13214                         flags ^= l_flags_vals[fcnt].bit;
13215                       }
13216                   if (flags != 0)
13217                     printf (" %#x", (unsigned int) flags);
13218
13219                   puts ("");
13220                 }
13221             }
13222
13223           free (elib);
13224         }
13225     }
13226
13227   if (options_offset != 0)
13228     {
13229       Elf_External_Options * eopt;
13230       Elf_Internal_Options * iopt;
13231       Elf_Internal_Options * option;
13232       size_t offset;
13233       int cnt;
13234       sect = section_headers;
13235
13236       /* Find the section header so that we get the size.  */
13237       while (sect->sh_type != SHT_MIPS_OPTIONS)
13238         ++sect;
13239
13240       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13241                                                 sect->sh_size, _("options"));
13242       if (eopt)
13243         {
13244           iopt = (Elf_Internal_Options *)
13245               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13246           if (iopt == NULL)
13247             {
13248               error (_("Out of memory\n"));
13249               return 0;
13250             }
13251
13252           offset = cnt = 0;
13253           option = iopt;
13254
13255           while (offset < sect->sh_size)
13256             {
13257               Elf_External_Options * eoption;
13258
13259               eoption = (Elf_External_Options *) ((char *) eopt + offset);
13260
13261               option->kind = BYTE_GET (eoption->kind);
13262               option->size = BYTE_GET (eoption->size);
13263               option->section = BYTE_GET (eoption->section);
13264               option->info = BYTE_GET (eoption->info);
13265
13266               offset += option->size;
13267
13268               ++option;
13269               ++cnt;
13270             }
13271
13272           printf (_("\nSection '%s' contains %d entries:\n"),
13273                   printable_section_name (sect), cnt);
13274
13275           option = iopt;
13276
13277           while (cnt-- > 0)
13278             {
13279               size_t len;
13280
13281               switch (option->kind)
13282                 {
13283                 case ODK_NULL:
13284                   /* This shouldn't happen.  */
13285                   printf (" NULL       %d %lx", option->section, option->info);
13286                   break;
13287                 case ODK_REGINFO:
13288                   printf (" REGINFO    ");
13289                   if (elf_header.e_machine == EM_MIPS)
13290                     {
13291                       /* 32bit form.  */
13292                       Elf32_External_RegInfo * ereg;
13293                       Elf32_RegInfo reginfo;
13294
13295                       ereg = (Elf32_External_RegInfo *) (option + 1);
13296                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13297                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13298                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13299                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13300                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13301                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13302
13303                       printf ("GPR %08lx  GP 0x%lx\n",
13304                               reginfo.ri_gprmask,
13305                               (unsigned long) reginfo.ri_gp_value);
13306                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13307                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13308                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13309                     }
13310                   else
13311                     {
13312                       /* 64 bit form.  */
13313                       Elf64_External_RegInfo * ereg;
13314                       Elf64_Internal_RegInfo reginfo;
13315
13316                       ereg = (Elf64_External_RegInfo *) (option + 1);
13317                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
13318                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13319                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13320                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13321                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13322                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
13323
13324                       printf ("GPR %08lx  GP 0x",
13325                               reginfo.ri_gprmask);
13326                       printf_vma (reginfo.ri_gp_value);
13327                       printf ("\n");
13328
13329                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13330                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13331                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13332                     }
13333                   ++option;
13334                   continue;
13335                 case ODK_EXCEPTIONS:
13336                   fputs (" EXCEPTIONS fpe_min(", stdout);
13337                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13338                   fputs (") fpe_max(", stdout);
13339                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13340                   fputs (")", stdout);
13341
13342                   if (option->info & OEX_PAGE0)
13343                     fputs (" PAGE0", stdout);
13344                   if (option->info & OEX_SMM)
13345                     fputs (" SMM", stdout);
13346                   if (option->info & OEX_FPDBUG)
13347                     fputs (" FPDBUG", stdout);
13348                   if (option->info & OEX_DISMISS)
13349                     fputs (" DISMISS", stdout);
13350                   break;
13351                 case ODK_PAD:
13352                   fputs (" PAD       ", stdout);
13353                   if (option->info & OPAD_PREFIX)
13354                     fputs (" PREFIX", stdout);
13355                   if (option->info & OPAD_POSTFIX)
13356                     fputs (" POSTFIX", stdout);
13357                   if (option->info & OPAD_SYMBOL)
13358                     fputs (" SYMBOL", stdout);
13359                   break;
13360                 case ODK_HWPATCH:
13361                   fputs (" HWPATCH   ", stdout);
13362                   if (option->info & OHW_R4KEOP)
13363                     fputs (" R4KEOP", stdout);
13364                   if (option->info & OHW_R8KPFETCH)
13365                     fputs (" R8KPFETCH", stdout);
13366                   if (option->info & OHW_R5KEOP)
13367                     fputs (" R5KEOP", stdout);
13368                   if (option->info & OHW_R5KCVTL)
13369                     fputs (" R5KCVTL", stdout);
13370                   break;
13371                 case ODK_FILL:
13372                   fputs (" FILL       ", stdout);
13373                   /* XXX Print content of info word?  */
13374                   break;
13375                 case ODK_TAGS:
13376                   fputs (" TAGS       ", stdout);
13377                   /* XXX Print content of info word?  */
13378                   break;
13379                 case ODK_HWAND:
13380                   fputs (" HWAND     ", stdout);
13381                   if (option->info & OHWA0_R4KEOP_CHECKED)
13382                     fputs (" R4KEOP_CHECKED", stdout);
13383                   if (option->info & OHWA0_R4KEOP_CLEAN)
13384                     fputs (" R4KEOP_CLEAN", stdout);
13385                   break;
13386                 case ODK_HWOR:
13387                   fputs (" HWOR      ", stdout);
13388                   if (option->info & OHWA0_R4KEOP_CHECKED)
13389                     fputs (" R4KEOP_CHECKED", stdout);
13390                   if (option->info & OHWA0_R4KEOP_CLEAN)
13391                     fputs (" R4KEOP_CLEAN", stdout);
13392                   break;
13393                 case ODK_GP_GROUP:
13394                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
13395                           option->info & OGP_GROUP,
13396                           (option->info & OGP_SELF) >> 16);
13397                   break;
13398                 case ODK_IDENT:
13399                   printf (" IDENT     %#06lx  self-contained %#06lx",
13400                           option->info & OGP_GROUP,
13401                           (option->info & OGP_SELF) >> 16);
13402                   break;
13403                 default:
13404                   /* This shouldn't happen.  */
13405                   printf (" %3d ???     %d %lx",
13406                           option->kind, option->section, option->info);
13407                   break;
13408                 }
13409
13410               len = sizeof (* eopt);
13411               while (len < option->size)
13412                 if (((char *) option)[len] >= ' '
13413                     && ((char *) option)[len] < 0x7f)
13414                   printf ("%c", ((char *) option)[len++]);
13415                 else
13416                   printf ("\\%03o", ((char *) option)[len++]);
13417
13418               fputs ("\n", stdout);
13419               ++option;
13420             }
13421
13422           free (eopt);
13423         }
13424     }
13425
13426   if (conflicts_offset != 0 && conflictsno != 0)
13427     {
13428       Elf32_Conflict * iconf;
13429       size_t cnt;
13430
13431       if (dynamic_symbols == NULL)
13432         {
13433           error (_("conflict list found without a dynamic symbol table\n"));
13434           return 0;
13435         }
13436
13437       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13438       if (iconf == NULL)
13439         {
13440           error (_("Out of memory\n"));
13441           return 0;
13442         }
13443
13444       if (is_32bit_elf)
13445         {
13446           Elf32_External_Conflict * econf32;
13447
13448           econf32 = (Elf32_External_Conflict *)
13449               get_data (NULL, file, conflicts_offset, conflictsno,
13450                         sizeof (* econf32), _("conflict"));
13451           if (!econf32)
13452             return 0;
13453
13454           for (cnt = 0; cnt < conflictsno; ++cnt)
13455             iconf[cnt] = BYTE_GET (econf32[cnt]);
13456
13457           free (econf32);
13458         }
13459       else
13460         {
13461           Elf64_External_Conflict * econf64;
13462
13463           econf64 = (Elf64_External_Conflict *)
13464               get_data (NULL, file, conflicts_offset, conflictsno,
13465                         sizeof (* econf64), _("conflict"));
13466           if (!econf64)
13467             return 0;
13468
13469           for (cnt = 0; cnt < conflictsno; ++cnt)
13470             iconf[cnt] = BYTE_GET (econf64[cnt]);
13471
13472           free (econf64);
13473         }
13474
13475       printf (_("\nSection '.conflict' contains %lu entries:\n"),
13476               (unsigned long) conflictsno);
13477       puts (_("  Num:    Index       Value  Name"));
13478
13479       for (cnt = 0; cnt < conflictsno; ++cnt)
13480         {
13481           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
13482
13483           if (iconf[cnt] >= num_dynamic_syms)
13484             printf (_("<corrupt symbol index>"));
13485           else
13486             {
13487               Elf_Internal_Sym * psym;
13488
13489               psym = & dynamic_symbols[iconf[cnt]];
13490               print_vma (psym->st_value, FULL_HEX);
13491               putchar (' ');
13492               if (VALID_DYNAMIC_NAME (psym->st_name))
13493                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13494               else
13495                 printf (_("<corrupt: %14ld>"), psym->st_name);
13496             }
13497           putchar ('\n');
13498         }
13499
13500       free (iconf);
13501     }
13502
13503   if (pltgot != 0 && local_gotno != 0)
13504     {
13505       bfd_vma ent, local_end, global_end;
13506       size_t i, offset;
13507       unsigned char * data;
13508       int addr_size;
13509
13510       ent = pltgot;
13511       addr_size = (is_32bit_elf ? 4 : 8);
13512       local_end = pltgot + local_gotno * addr_size;
13513
13514       /* PR binutils/17533 file: 012-111227-0.004  */
13515       if (symtabno < gotsym)
13516         {
13517           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13518                  (long) gotsym, (long) symtabno);
13519           return 0;
13520         }
13521
13522       global_end = local_end + (symtabno - gotsym) * addr_size;
13523       assert (global_end >= local_end);
13524       offset = offset_from_vma (file, pltgot, global_end - pltgot);
13525       data = (unsigned char *) get_data (NULL, file, offset,
13526                                          global_end - pltgot, 1,
13527                                          _("Global Offset Table data"));
13528       if (data == NULL)
13529         return 0;
13530
13531       printf (_("\nPrimary GOT:\n"));
13532       printf (_(" Canonical gp value: "));
13533       print_vma (pltgot + 0x7ff0, LONG_HEX);
13534       printf ("\n\n");
13535
13536       printf (_(" Reserved entries:\n"));
13537       printf (_("  %*s %10s %*s Purpose\n"),
13538               addr_size * 2, _("Address"), _("Access"),
13539               addr_size * 2, _("Initial"));
13540       ent = print_mips_got_entry (data, pltgot, ent);
13541       printf (_(" Lazy resolver\n"));
13542       if (data
13543           && (byte_get (data + ent - pltgot, addr_size)
13544               >> (addr_size * 8 - 1)) != 0)
13545         {
13546           ent = print_mips_got_entry (data, pltgot, ent);
13547           printf (_(" Module pointer (GNU extension)\n"));
13548         }
13549       printf ("\n");
13550
13551       if (ent < local_end)
13552         {
13553           printf (_(" Local entries:\n"));
13554           printf ("  %*s %10s %*s\n",
13555                   addr_size * 2, _("Address"), _("Access"),
13556                   addr_size * 2, _("Initial"));
13557           while (ent < local_end)
13558             {
13559               ent = print_mips_got_entry (data, pltgot, ent);
13560               printf ("\n");
13561             }
13562           printf ("\n");
13563         }
13564
13565       if (gotsym < symtabno)
13566         {
13567           int sym_width;
13568
13569           printf (_(" Global entries:\n"));
13570           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
13571                   addr_size * 2, _("Address"),
13572                   _("Access"),
13573                   addr_size * 2, _("Initial"),
13574                   addr_size * 2, _("Sym.Val."),
13575                   _("Type"),
13576                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
13577                   _("Ndx"), _("Name"));
13578
13579           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13580
13581           for (i = gotsym; i < symtabno; i++)
13582             {
13583               ent = print_mips_got_entry (data, pltgot, ent);
13584               printf (" ");
13585
13586               if (dynamic_symbols == NULL)
13587                 printf (_("<no dynamic symbols>"));
13588               else if (i < num_dynamic_syms)
13589                 {
13590                   Elf_Internal_Sym * psym = dynamic_symbols + i;
13591
13592                   print_vma (psym->st_value, LONG_HEX);
13593                   printf (" %-7s %3s ",
13594                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13595                           get_symbol_index_type (psym->st_shndx));
13596
13597                   if (VALID_DYNAMIC_NAME (psym->st_name))
13598                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13599                   else
13600                     printf (_("<corrupt: %14ld>"), psym->st_name);
13601                 }
13602               else
13603                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13604                         (unsigned long) i);
13605
13606               printf ("\n");
13607             }
13608           printf ("\n");
13609         }
13610
13611       if (data)
13612         free (data);
13613     }
13614
13615   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13616     {
13617       bfd_vma ent, end;
13618       size_t offset, rel_offset;
13619       unsigned long count, i;
13620       unsigned char * data;
13621       int addr_size, sym_width;
13622       Elf_Internal_Rela * rels;
13623
13624       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13625       if (pltrel == DT_RELA)
13626         {
13627           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13628             return 0;
13629         }
13630       else
13631         {
13632           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13633             return 0;
13634         }
13635
13636       ent = mips_pltgot;
13637       addr_size = (is_32bit_elf ? 4 : 8);
13638       end = mips_pltgot + (2 + count) * addr_size;
13639
13640       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13641       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13642                                          1, _("Procedure Linkage Table data"));
13643       if (data == NULL)
13644         return 0;
13645
13646       printf ("\nPLT GOT:\n\n");
13647       printf (_(" Reserved entries:\n"));
13648       printf (_("  %*s %*s Purpose\n"),
13649               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13650       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13651       printf (_(" PLT lazy resolver\n"));
13652       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13653       printf (_(" Module pointer\n"));
13654       printf ("\n");
13655
13656       printf (_(" Entries:\n"));
13657       printf ("  %*s %*s %*s %-7s %3s %s\n",
13658               addr_size * 2, _("Address"),
13659               addr_size * 2, _("Initial"),
13660               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13661       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13662       for (i = 0; i < count; i++)
13663         {
13664           unsigned long idx = get_reloc_symindex (rels[i].r_info);
13665
13666           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13667           printf (" ");
13668
13669           if (idx >= num_dynamic_syms)
13670             printf (_("<corrupt symbol index: %lu>"), idx);
13671           else
13672             {
13673               Elf_Internal_Sym * psym = dynamic_symbols + idx;
13674
13675               print_vma (psym->st_value, LONG_HEX);
13676               printf (" %-7s %3s ",
13677                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13678                       get_symbol_index_type (psym->st_shndx));
13679               if (VALID_DYNAMIC_NAME (psym->st_name))
13680                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13681               else
13682                 printf (_("<corrupt: %14ld>"), psym->st_name);
13683             }
13684           printf ("\n");
13685         }
13686       printf ("\n");
13687
13688       if (data)
13689         free (data);
13690       free (rels);
13691     }
13692
13693   return 1;
13694 }
13695
13696 static int
13697 process_nds32_specific (FILE * file)
13698 {
13699   Elf_Internal_Shdr *sect = NULL;
13700
13701   sect = find_section (".nds32_e_flags");
13702   if (sect != NULL)
13703     {
13704       unsigned int *flag;
13705
13706       printf ("\nNDS32 elf flags section:\n");
13707       flag = get_data (NULL, file, sect->sh_offset, 1,
13708                        sect->sh_size, _("NDS32 elf flags section"));
13709
13710       switch ((*flag) & 0x3)
13711         {
13712         case 0:
13713           printf ("(VEC_SIZE):\tNo entry.\n");
13714           break;
13715         case 1:
13716           printf ("(VEC_SIZE):\t4 bytes\n");
13717           break;
13718         case 2:
13719           printf ("(VEC_SIZE):\t16 bytes\n");
13720           break;
13721         case 3:
13722           printf ("(VEC_SIZE):\treserved\n");
13723           break;
13724         }
13725     }
13726
13727   return TRUE;
13728 }
13729
13730 static int
13731 process_gnu_liblist (FILE * file)
13732 {
13733   Elf_Internal_Shdr * section;
13734   Elf_Internal_Shdr * string_sec;
13735   Elf32_External_Lib * elib;
13736   char * strtab;
13737   size_t strtab_size;
13738   size_t cnt;
13739   unsigned i;
13740
13741   if (! do_arch)
13742     return 0;
13743
13744   for (i = 0, section = section_headers;
13745        i < elf_header.e_shnum;
13746        i++, section++)
13747     {
13748       switch (section->sh_type)
13749         {
13750         case SHT_GNU_LIBLIST:
13751           if (section->sh_link >= elf_header.e_shnum)
13752             break;
13753
13754           elib = (Elf32_External_Lib *)
13755               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13756                         _("liblist section data"));
13757
13758           if (elib == NULL)
13759             break;
13760           string_sec = section_headers + section->sh_link;
13761
13762           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13763                                       string_sec->sh_size,
13764                                       _("liblist string table"));
13765           if (strtab == NULL
13766               || section->sh_entsize != sizeof (Elf32_External_Lib))
13767             {
13768               free (elib);
13769               free (strtab);
13770               break;
13771             }
13772           strtab_size = string_sec->sh_size;
13773
13774           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13775                   printable_section_name (section),
13776                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13777
13778           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13779
13780           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13781                ++cnt)
13782             {
13783               Elf32_Lib liblist;
13784               time_t atime;
13785               char timebuf[20];
13786               struct tm * tmp;
13787
13788               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13789               atime = BYTE_GET (elib[cnt].l_time_stamp);
13790               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13791               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13792               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13793
13794               tmp = gmtime (&atime);
13795               snprintf (timebuf, sizeof (timebuf),
13796                         "%04u-%02u-%02uT%02u:%02u:%02u",
13797                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13798                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13799
13800               printf ("%3lu: ", (unsigned long) cnt);
13801               if (do_wide)
13802                 printf ("%-20s", liblist.l_name < strtab_size
13803                         ? strtab + liblist.l_name : _("<corrupt>"));
13804               else
13805                 printf ("%-20.20s", liblist.l_name < strtab_size
13806                         ? strtab + liblist.l_name : _("<corrupt>"));
13807               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13808                       liblist.l_version, liblist.l_flags);
13809             }
13810
13811           free (elib);
13812           free (strtab);
13813         }
13814     }
13815
13816   return 1;
13817 }
13818
13819 static const char *
13820 get_note_type (unsigned e_type)
13821 {
13822   static char buff[64];
13823
13824   if (elf_header.e_type == ET_CORE)
13825     switch (e_type)
13826       {
13827       case NT_AUXV:
13828         return _("NT_AUXV (auxiliary vector)");
13829       case NT_PRSTATUS:
13830         return _("NT_PRSTATUS (prstatus structure)");
13831       case NT_FPREGSET:
13832         return _("NT_FPREGSET (floating point registers)");
13833       case NT_PRPSINFO:
13834         return _("NT_PRPSINFO (prpsinfo structure)");
13835       case NT_TASKSTRUCT:
13836         return _("NT_TASKSTRUCT (task structure)");
13837       case NT_PRXFPREG:
13838         return _("NT_PRXFPREG (user_xfpregs structure)");
13839       case NT_PPC_VMX:
13840         return _("NT_PPC_VMX (ppc Altivec registers)");
13841       case NT_PPC_VSX:
13842         return _("NT_PPC_VSX (ppc VSX registers)");
13843       case NT_386_TLS:
13844         return _("NT_386_TLS (x86 TLS information)");
13845       case NT_386_IOPERM:
13846         return _("NT_386_IOPERM (x86 I/O permissions)");
13847       case NT_X86_XSTATE:
13848         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13849       case NT_S390_HIGH_GPRS:
13850         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13851       case NT_S390_TIMER:
13852         return _("NT_S390_TIMER (s390 timer register)");
13853       case NT_S390_TODCMP:
13854         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13855       case NT_S390_TODPREG:
13856         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13857       case NT_S390_CTRS:
13858         return _("NT_S390_CTRS (s390 control registers)");
13859       case NT_S390_PREFIX:
13860         return _("NT_S390_PREFIX (s390 prefix register)");
13861       case NT_S390_LAST_BREAK:
13862         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13863       case NT_S390_SYSTEM_CALL:
13864         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13865       case NT_S390_TDB:
13866         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13867       case NT_ARM_VFP:
13868         return _("NT_ARM_VFP (arm VFP registers)");
13869       case NT_ARM_TLS:
13870         return _("NT_ARM_TLS (AArch TLS registers)");
13871       case NT_ARM_HW_BREAK:
13872         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13873       case NT_ARM_HW_WATCH:
13874         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13875       case NT_PSTATUS:
13876         return _("NT_PSTATUS (pstatus structure)");
13877       case NT_FPREGS:
13878         return _("NT_FPREGS (floating point registers)");
13879       case NT_PSINFO:
13880         return _("NT_PSINFO (psinfo structure)");
13881       case NT_LWPSTATUS:
13882         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13883       case NT_LWPSINFO:
13884         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13885       case NT_WIN32PSTATUS:
13886         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13887       case NT_SIGINFO:
13888         return _("NT_SIGINFO (siginfo_t data)");
13889       case NT_FILE:
13890         return _("NT_FILE (mapped files)");
13891       default:
13892         break;
13893       }
13894   else
13895     switch (e_type)
13896       {
13897       case NT_VERSION:
13898         return _("NT_VERSION (version)");
13899       case NT_ARCH:
13900         return _("NT_ARCH (architecture)");
13901       default:
13902         break;
13903       }
13904
13905   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13906   return buff;
13907 }
13908
13909 static int
13910 print_core_note (Elf_Internal_Note *pnote)
13911 {
13912   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13913   bfd_vma count, page_size;
13914   unsigned char *descdata, *filenames, *descend;
13915
13916   if (pnote->type != NT_FILE)
13917     return 1;
13918
13919 #ifndef BFD64
13920   if (!is_32bit_elf)
13921     {
13922       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13923       /* Still "successful".  */
13924       return 1;
13925     }
13926 #endif
13927
13928   if (pnote->descsz < 2 * addr_size)
13929     {
13930       printf (_("    Malformed note - too short for header\n"));
13931       return 0;
13932     }
13933
13934   descdata = (unsigned char *) pnote->descdata;
13935   descend = descdata + pnote->descsz;
13936
13937   if (descdata[pnote->descsz - 1] != '\0')
13938     {
13939       printf (_("    Malformed note - does not end with \\0\n"));
13940       return 0;
13941     }
13942
13943   count = byte_get (descdata, addr_size);
13944   descdata += addr_size;
13945
13946   page_size = byte_get (descdata, addr_size);
13947   descdata += addr_size;
13948
13949   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13950     {
13951       printf (_("    Malformed note - too short for supplied file count\n"));
13952       return 0;
13953     }
13954
13955   printf (_("    Page size: "));
13956   print_vma (page_size, DEC);
13957   printf ("\n");
13958
13959   printf (_("    %*s%*s%*s\n"),
13960           (int) (2 + 2 * addr_size), _("Start"),
13961           (int) (4 + 2 * addr_size), _("End"),
13962           (int) (4 + 2 * addr_size), _("Page Offset"));
13963   filenames = descdata + count * 3 * addr_size;
13964   while (--count > 0)
13965     {
13966       bfd_vma start, end, file_ofs;
13967
13968       if (filenames == descend)
13969         {
13970           printf (_("    Malformed note - filenames end too early\n"));
13971           return 0;
13972         }
13973
13974       start = byte_get (descdata, addr_size);
13975       descdata += addr_size;
13976       end = byte_get (descdata, addr_size);
13977       descdata += addr_size;
13978       file_ofs = byte_get (descdata, addr_size);
13979       descdata += addr_size;
13980
13981       printf ("    ");
13982       print_vma (start, FULL_HEX);
13983       printf ("  ");
13984       print_vma (end, FULL_HEX);
13985       printf ("  ");
13986       print_vma (file_ofs, FULL_HEX);
13987       printf ("\n        %s\n", filenames);
13988
13989       filenames += 1 + strlen ((char *) filenames);
13990     }
13991
13992   return 1;
13993 }
13994
13995 static const char *
13996 get_gnu_elf_note_type (unsigned e_type)
13997 {
13998   static char buff[64];
13999
14000   switch (e_type)
14001     {
14002     case NT_GNU_ABI_TAG:
14003       return _("NT_GNU_ABI_TAG (ABI version tag)");
14004     case NT_GNU_HWCAP:
14005       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14006     case NT_GNU_BUILD_ID:
14007       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14008     case NT_GNU_GOLD_VERSION:
14009       return _("NT_GNU_GOLD_VERSION (gold version)");
14010     default:
14011       break;
14012     }
14013
14014   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14015   return buff;
14016 }
14017
14018 static int
14019 print_gnu_note (Elf_Internal_Note *pnote)
14020 {
14021   switch (pnote->type)
14022     {
14023     case NT_GNU_BUILD_ID:
14024       {
14025         unsigned long i;
14026
14027         printf (_("    Build ID: "));
14028         for (i = 0; i < pnote->descsz; ++i)
14029           printf ("%02x", pnote->descdata[i] & 0xff);
14030         printf ("\n");
14031       }
14032       break;
14033
14034     case NT_GNU_ABI_TAG:
14035       {
14036         unsigned long os, major, minor, subminor;
14037         const char *osname;
14038
14039         os = byte_get ((unsigned char *) pnote->descdata, 4);
14040         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14041         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14042         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14043
14044         switch (os)
14045           {
14046           case GNU_ABI_TAG_LINUX:
14047             osname = "Linux";
14048             break;
14049           case GNU_ABI_TAG_HURD:
14050             osname = "Hurd";
14051             break;
14052           case GNU_ABI_TAG_SOLARIS:
14053             osname = "Solaris";
14054             break;
14055           case GNU_ABI_TAG_FREEBSD:
14056             osname = "FreeBSD";
14057             break;
14058           case GNU_ABI_TAG_NETBSD:
14059             osname = "NetBSD";
14060             break;
14061           default:
14062             osname = "Unknown";
14063             break;
14064           }
14065
14066         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14067                 major, minor, subminor);
14068       }
14069       break;
14070
14071     case NT_GNU_GOLD_VERSION:
14072       {
14073         unsigned long i;
14074
14075         printf (_("    Version: "));
14076         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14077           printf ("%c", pnote->descdata[i]);
14078         printf ("\n");
14079       }
14080       break;
14081     }
14082
14083   return 1;
14084 }
14085
14086 static const char *
14087 get_netbsd_elfcore_note_type (unsigned e_type)
14088 {
14089   static char buff[64];
14090
14091   if (e_type == NT_NETBSDCORE_PROCINFO)
14092     {
14093       /* NetBSD core "procinfo" structure.  */
14094       return _("NetBSD procinfo structure");
14095     }
14096
14097   /* As of Jan 2002 there are no other machine-independent notes
14098      defined for NetBSD core files.  If the note type is less
14099      than the start of the machine-dependent note types, we don't
14100      understand it.  */
14101
14102   if (e_type < NT_NETBSDCORE_FIRSTMACH)
14103     {
14104       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14105       return buff;
14106     }
14107
14108   switch (elf_header.e_machine)
14109     {
14110     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14111        and PT_GETFPREGS == mach+2.  */
14112
14113     case EM_OLD_ALPHA:
14114     case EM_ALPHA:
14115     case EM_SPARC:
14116     case EM_SPARC32PLUS:
14117     case EM_SPARCV9:
14118       switch (e_type)
14119         {
14120         case NT_NETBSDCORE_FIRSTMACH + 0:
14121           return _("PT_GETREGS (reg structure)");
14122         case NT_NETBSDCORE_FIRSTMACH + 2:
14123           return _("PT_GETFPREGS (fpreg structure)");
14124         default:
14125           break;
14126         }
14127       break;
14128
14129     /* On all other arch's, PT_GETREGS == mach+1 and
14130        PT_GETFPREGS == mach+3.  */
14131     default:
14132       switch (e_type)
14133         {
14134         case NT_NETBSDCORE_FIRSTMACH + 1:
14135           return _("PT_GETREGS (reg structure)");
14136         case NT_NETBSDCORE_FIRSTMACH + 3:
14137           return _("PT_GETFPREGS (fpreg structure)");
14138         default:
14139           break;
14140         }
14141     }
14142
14143   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14144             e_type - NT_NETBSDCORE_FIRSTMACH);
14145   return buff;
14146 }
14147
14148 static const char *
14149 get_stapsdt_note_type (unsigned e_type)
14150 {
14151   static char buff[64];
14152
14153   switch (e_type)
14154     {
14155     case NT_STAPSDT:
14156       return _("NT_STAPSDT (SystemTap probe descriptors)");
14157
14158     default:
14159       break;
14160     }
14161
14162   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14163   return buff;
14164 }
14165
14166 static int
14167 print_stapsdt_note (Elf_Internal_Note *pnote)
14168 {
14169   int addr_size = is_32bit_elf ? 4 : 8;
14170   char *data = pnote->descdata;
14171   char *data_end = pnote->descdata + pnote->descsz;
14172   bfd_vma pc, base_addr, semaphore;
14173   char *provider, *probe, *arg_fmt;
14174
14175   pc = byte_get ((unsigned char *) data, addr_size);
14176   data += addr_size;
14177   base_addr = byte_get ((unsigned char *) data, addr_size);
14178   data += addr_size;
14179   semaphore = byte_get ((unsigned char *) data, addr_size);
14180   data += addr_size;
14181
14182   provider = data;
14183   data += strlen (data) + 1;
14184   probe = data;
14185   data += strlen (data) + 1;
14186   arg_fmt = data;
14187   data += strlen (data) + 1;
14188
14189   printf (_("    Provider: %s\n"), provider);
14190   printf (_("    Name: %s\n"), probe);
14191   printf (_("    Location: "));
14192   print_vma (pc, FULL_HEX);
14193   printf (_(", Base: "));
14194   print_vma (base_addr, FULL_HEX);
14195   printf (_(", Semaphore: "));
14196   print_vma (semaphore, FULL_HEX);
14197   printf ("\n");
14198   printf (_("    Arguments: %s\n"), arg_fmt);
14199
14200   return data == data_end;
14201 }
14202
14203 static const char *
14204 get_ia64_vms_note_type (unsigned e_type)
14205 {
14206   static char buff[64];
14207
14208   switch (e_type)
14209     {
14210     case NT_VMS_MHD:
14211       return _("NT_VMS_MHD (module header)");
14212     case NT_VMS_LNM:
14213       return _("NT_VMS_LNM (language name)");
14214     case NT_VMS_SRC:
14215       return _("NT_VMS_SRC (source files)");
14216     case NT_VMS_TITLE:
14217       return "NT_VMS_TITLE";
14218     case NT_VMS_EIDC:
14219       return _("NT_VMS_EIDC (consistency check)");
14220     case NT_VMS_FPMODE:
14221       return _("NT_VMS_FPMODE (FP mode)");
14222     case NT_VMS_LINKTIME:
14223       return "NT_VMS_LINKTIME";
14224     case NT_VMS_IMGNAM:
14225       return _("NT_VMS_IMGNAM (image name)");
14226     case NT_VMS_IMGID:
14227       return _("NT_VMS_IMGID (image id)");
14228     case NT_VMS_LINKID:
14229       return _("NT_VMS_LINKID (link id)");
14230     case NT_VMS_IMGBID:
14231       return _("NT_VMS_IMGBID (build id)");
14232     case NT_VMS_GSTNAM:
14233       return _("NT_VMS_GSTNAM (sym table name)");
14234     case NT_VMS_ORIG_DYN:
14235       return "NT_VMS_ORIG_DYN";
14236     case NT_VMS_PATCHTIME:
14237       return "NT_VMS_PATCHTIME";
14238     default:
14239       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14240       return buff;
14241     }
14242 }
14243
14244 static int
14245 print_ia64_vms_note (Elf_Internal_Note * pnote)
14246 {
14247   switch (pnote->type)
14248     {
14249     case NT_VMS_MHD:
14250       if (pnote->descsz > 36)
14251         {
14252           size_t l = strlen (pnote->descdata + 34);
14253           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
14254           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
14255           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
14256           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
14257         }
14258       else
14259         printf (_("    Invalid size\n"));
14260       break;
14261     case NT_VMS_LNM:
14262       printf (_("   Language: %s\n"), pnote->descdata);
14263       break;
14264 #ifdef BFD64
14265     case NT_VMS_FPMODE:
14266       printf (_("   Floating Point mode: "));
14267       printf ("0x%016" BFD_VMA_FMT "x\n",
14268               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14269       break;
14270     case NT_VMS_LINKTIME:
14271       printf (_("   Link time: "));
14272       print_vms_time
14273         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14274       printf ("\n");
14275       break;
14276     case NT_VMS_PATCHTIME:
14277       printf (_("   Patch time: "));
14278       print_vms_time
14279         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14280       printf ("\n");
14281       break;
14282     case NT_VMS_ORIG_DYN:
14283       printf (_("   Major id: %u,  minor id: %u\n"),
14284               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14285               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14286       printf (_("   Last modified  : "));
14287       print_vms_time
14288         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14289       printf (_("\n   Link flags  : "));
14290       printf ("0x%016" BFD_VMA_FMT "x\n",
14291               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14292       printf (_("   Header flags: 0x%08x\n"),
14293               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14294       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
14295       break;
14296 #endif
14297     case NT_VMS_IMGNAM:
14298       printf (_("    Image name: %s\n"), pnote->descdata);
14299       break;
14300     case NT_VMS_GSTNAM:
14301       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
14302       break;
14303     case NT_VMS_IMGID:
14304       printf (_("    Image id: %s\n"), pnote->descdata);
14305       break;
14306     case NT_VMS_LINKID:
14307       printf (_("    Linker id: %s\n"), pnote->descdata);
14308       break;
14309     default:
14310       break;
14311     }
14312   return 1;
14313 }
14314
14315 /* Note that by the ELF standard, the name field is already null byte
14316    terminated, and namesz includes the terminating null byte.
14317    I.E. the value of namesz for the name "FSF" is 4.
14318
14319    If the value of namesz is zero, there is no name present.  */
14320 static int
14321 process_note (Elf_Internal_Note * pnote)
14322 {
14323   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14324   const char * nt;
14325
14326   if (pnote->namesz == 0)
14327     /* If there is no note name, then use the default set of
14328        note type strings.  */
14329     nt = get_note_type (pnote->type);
14330
14331   else if (const_strneq (pnote->namedata, "GNU"))
14332     /* GNU-specific object file notes.  */
14333     nt = get_gnu_elf_note_type (pnote->type);
14334
14335   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14336     /* NetBSD-specific core file notes.  */
14337     nt = get_netbsd_elfcore_note_type (pnote->type);
14338
14339   else if (strneq (pnote->namedata, "SPU/", 4))
14340     {
14341       /* SPU-specific core file notes.  */
14342       nt = pnote->namedata + 4;
14343       name = "SPU";
14344     }
14345
14346   else if (const_strneq (pnote->namedata, "IPF/VMS"))
14347     /* VMS/ia64-specific file notes.  */
14348     nt = get_ia64_vms_note_type (pnote->type);
14349
14350   else if (const_strneq (pnote->namedata, "stapsdt"))
14351     nt = get_stapsdt_note_type (pnote->type);
14352
14353   else
14354     /* Don't recognize this note name; just use the default set of
14355        note type strings.  */
14356     nt = get_note_type (pnote->type);
14357
14358   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14359
14360   if (const_strneq (pnote->namedata, "IPF/VMS"))
14361     return print_ia64_vms_note (pnote);
14362   else if (const_strneq (pnote->namedata, "GNU"))
14363     return print_gnu_note (pnote);
14364   else if (const_strneq (pnote->namedata, "stapsdt"))
14365     return print_stapsdt_note (pnote);
14366   else if (const_strneq (pnote->namedata, "CORE"))
14367     return print_core_note (pnote);
14368   else
14369     return 1;
14370 }
14371
14372
14373 static int
14374 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14375 {
14376   Elf_External_Note * pnotes;
14377   Elf_External_Note * external;
14378   int res = 1;
14379
14380   if (length <= 0)
14381     return 0;
14382
14383   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14384                                            _("notes"));
14385   if (pnotes == NULL)
14386     return 0;
14387
14388   external = pnotes;
14389
14390   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14391           (unsigned long) offset, (unsigned long) length);
14392   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14393
14394   while ((char *) external < (char *) pnotes + length)
14395     {
14396       Elf_Internal_Note inote;
14397       size_t min_notesz;
14398       char *next;
14399       char * temp = NULL;
14400       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14401
14402       if (!is_ia64_vms ())
14403         {
14404           /* PR binutils/15191
14405              Make sure that there is enough data to read.  */
14406           min_notesz = offsetof (Elf_External_Note, name);
14407           if (data_remaining < min_notesz)
14408             {
14409               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14410                     (int) data_remaining);
14411               break;
14412             }
14413           inote.type     = BYTE_GET (external->type);
14414           inote.namesz   = BYTE_GET (external->namesz);
14415           inote.namedata = external->name;
14416           inote.descsz   = BYTE_GET (external->descsz);
14417           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14418           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14419           next = inote.descdata + align_power (inote.descsz, 2);
14420         }
14421       else
14422         {
14423           Elf64_External_VMS_Note *vms_external;
14424
14425           /* PR binutils/15191
14426              Make sure that there is enough data to read.  */
14427           min_notesz = offsetof (Elf64_External_VMS_Note, name);
14428           if (data_remaining < min_notesz)
14429             {
14430               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14431                     (int) data_remaining);
14432               break;
14433             }
14434
14435           vms_external = (Elf64_External_VMS_Note *) external;
14436           inote.type     = BYTE_GET (vms_external->type);
14437           inote.namesz   = BYTE_GET (vms_external->namesz);
14438           inote.namedata = vms_external->name;
14439           inote.descsz   = BYTE_GET (vms_external->descsz);
14440           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14441           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14442           next = inote.descdata + align_power (inote.descsz, 3);
14443         }
14444
14445       if (inote.descdata < (char *) external + min_notesz
14446           || next < (char *) external + min_notesz
14447           || data_remaining < (size_t)(next - (char *) external))
14448         {
14449           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14450                 (unsigned long) ((char *) external - (char *) pnotes));
14451           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14452                 inote.type, inote.namesz, inote.descsz);
14453           break;
14454         }
14455
14456       external = (Elf_External_Note *) next;
14457
14458       /* Verify that name is null terminated.  It appears that at least
14459          one version of Linux (RedHat 6.0) generates corefiles that don't
14460          comply with the ELF spec by failing to include the null byte in
14461          namesz.  */
14462       if (inote.namedata[inote.namesz - 1] != '\0')
14463         {
14464           temp = (char *) malloc (inote.namesz + 1);
14465
14466           if (temp == NULL)
14467             {
14468               error (_("Out of memory\n"));
14469               res = 0;
14470               break;
14471             }
14472
14473           strncpy (temp, inote.namedata, inote.namesz);
14474           temp[inote.namesz] = 0;
14475
14476           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
14477           inote.namedata = temp;
14478         }
14479
14480       res &= process_note (& inote);
14481
14482       if (temp != NULL)
14483         {
14484           free (temp);
14485           temp = NULL;
14486         }
14487     }
14488
14489   free (pnotes);
14490
14491   return res;
14492 }
14493
14494 static int
14495 process_corefile_note_segments (FILE * file)
14496 {
14497   Elf_Internal_Phdr * segment;
14498   unsigned int i;
14499   int res = 1;
14500
14501   if (! get_program_headers (file))
14502       return 0;
14503
14504   for (i = 0, segment = program_headers;
14505        i < elf_header.e_phnum;
14506        i++, segment++)
14507     {
14508       if (segment->p_type == PT_NOTE)
14509         res &= process_corefile_note_segment (file,
14510                                               (bfd_vma) segment->p_offset,
14511                                               (bfd_vma) segment->p_filesz);
14512     }
14513
14514   return res;
14515 }
14516
14517 static int
14518 process_note_sections (FILE * file)
14519 {
14520   Elf_Internal_Shdr * section;
14521   unsigned long i;
14522   int n = 0;
14523   int res = 1;
14524
14525   for (i = 0, section = section_headers;
14526        i < elf_header.e_shnum && section != NULL;
14527        i++, section++)
14528     if (section->sh_type == SHT_NOTE)
14529       {
14530         res &= process_corefile_note_segment (file,
14531                                               (bfd_vma) section->sh_offset,
14532                                               (bfd_vma) section->sh_size);
14533         n++;
14534       }
14535
14536   if (n == 0)
14537     /* Try processing NOTE segments instead.  */
14538     return process_corefile_note_segments (file);
14539
14540   return res;
14541 }
14542
14543 static int
14544 process_notes (FILE * file)
14545 {
14546   /* If we have not been asked to display the notes then do nothing.  */
14547   if (! do_notes)
14548     return 1;
14549
14550   if (elf_header.e_type != ET_CORE)
14551     return process_note_sections (file);
14552
14553   /* No program headers means no NOTE segment.  */
14554   if (elf_header.e_phnum > 0)
14555     return process_corefile_note_segments (file);
14556
14557   printf (_("No note segments present in the core file.\n"));
14558   return 1;
14559 }
14560
14561 static int
14562 process_arch_specific (FILE * file)
14563 {
14564   if (! do_arch)
14565     return 1;
14566
14567   switch (elf_header.e_machine)
14568     {
14569     case EM_ARM:
14570       return process_arm_specific (file);
14571     case EM_MIPS:
14572     case EM_MIPS_RS3_LE:
14573       return process_mips_specific (file);
14574       break;
14575     case EM_NDS32:
14576       return process_nds32_specific (file);
14577       break;
14578     case EM_PPC:
14579       return process_power_specific (file);
14580       break;
14581     case EM_SPARC:
14582     case EM_SPARC32PLUS:
14583     case EM_SPARCV9:
14584       return process_sparc_specific (file);
14585       break;
14586     case EM_TI_C6000:
14587       return process_tic6x_specific (file);
14588       break;
14589     case EM_MSP430:
14590       return process_msp430x_specific (file);
14591     default:
14592       break;
14593     }
14594   return 1;
14595 }
14596
14597 static int
14598 get_file_header (FILE * file)
14599 {
14600   /* Read in the identity array.  */
14601   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14602     return 0;
14603
14604   /* Determine how to read the rest of the header.  */
14605   switch (elf_header.e_ident[EI_DATA])
14606     {
14607     default: /* fall through */
14608     case ELFDATANONE: /* fall through */
14609     case ELFDATA2LSB:
14610       byte_get = byte_get_little_endian;
14611       byte_put = byte_put_little_endian;
14612       break;
14613     case ELFDATA2MSB:
14614       byte_get = byte_get_big_endian;
14615       byte_put = byte_put_big_endian;
14616       break;
14617     }
14618
14619   /* For now we only support 32 bit and 64 bit ELF files.  */
14620   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14621
14622   /* Read in the rest of the header.  */
14623   if (is_32bit_elf)
14624     {
14625       Elf32_External_Ehdr ehdr32;
14626
14627       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14628         return 0;
14629
14630       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
14631       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
14632       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
14633       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
14634       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
14635       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
14636       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
14637       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
14638       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14639       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
14640       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14641       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
14642       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
14643     }
14644   else
14645     {
14646       Elf64_External_Ehdr ehdr64;
14647
14648       /* If we have been compiled with sizeof (bfd_vma) == 4, then
14649          we will not be able to cope with the 64bit data found in
14650          64 ELF files.  Detect this now and abort before we start
14651          overwriting things.  */
14652       if (sizeof (bfd_vma) < 8)
14653         {
14654           error (_("This instance of readelf has been built without support for a\n\
14655 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14656           return 0;
14657         }
14658
14659       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14660         return 0;
14661
14662       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
14663       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
14664       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
14665       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
14666       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
14667       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
14668       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
14669       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
14670       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14671       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
14672       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14673       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
14674       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
14675     }
14676
14677   if (elf_header.e_shoff)
14678     {
14679       /* There may be some extensions in the first section header.  Don't
14680          bomb if we can't read it.  */
14681       if (is_32bit_elf)
14682         get_32bit_section_headers (file, TRUE);
14683       else
14684         get_64bit_section_headers (file, TRUE);
14685     }
14686
14687   return 1;
14688 }
14689
14690 /* Process one ELF object file according to the command line options.
14691    This file may actually be stored in an archive.  The file is
14692    positioned at the start of the ELF object.  */
14693
14694 static int
14695 process_object (char * file_name, FILE * file)
14696 {
14697   unsigned int i;
14698
14699   if (! get_file_header (file))
14700     {
14701       error (_("%s: Failed to read file header\n"), file_name);
14702       return 1;
14703     }
14704
14705   /* Initialise per file variables.  */
14706   for (i = ARRAY_SIZE (version_info); i--;)
14707     version_info[i] = 0;
14708
14709   for (i = ARRAY_SIZE (dynamic_info); i--;)
14710     dynamic_info[i] = 0;
14711   dynamic_info_DT_GNU_HASH = 0;
14712
14713   /* Process the file.  */
14714   if (show_name)
14715     printf (_("\nFile: %s\n"), file_name);
14716
14717   /* Initialise the dump_sects array from the cmdline_dump_sects array.
14718      Note we do this even if cmdline_dump_sects is empty because we
14719      must make sure that the dump_sets array is zeroed out before each
14720      object file is processed.  */
14721   if (num_dump_sects > num_cmdline_dump_sects)
14722     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14723
14724   if (num_cmdline_dump_sects > 0)
14725     {
14726       if (num_dump_sects == 0)
14727         /* A sneaky way of allocating the dump_sects array.  */
14728         request_dump_bynumber (num_cmdline_dump_sects, 0);
14729
14730       assert (num_dump_sects >= num_cmdline_dump_sects);
14731       memcpy (dump_sects, cmdline_dump_sects,
14732               num_cmdline_dump_sects * sizeof (* dump_sects));
14733     }
14734
14735   if (! process_file_header ())
14736     return 1;
14737
14738   if (! process_section_headers (file))
14739     {
14740       /* Without loaded section headers we cannot process lots of
14741          things.  */
14742       do_unwind = do_version = do_dump = do_arch = 0;
14743
14744       if (! do_using_dynamic)
14745         do_syms = do_dyn_syms = do_reloc = 0;
14746     }
14747
14748   if (! process_section_groups (file))
14749     {
14750       /* Without loaded section groups we cannot process unwind.  */
14751       do_unwind = 0;
14752     }
14753
14754   if (process_program_headers (file))
14755     process_dynamic_section (file);
14756
14757   process_relocs (file);
14758
14759   process_unwind (file);
14760
14761   process_symbol_table (file);
14762
14763   process_syminfo (file);
14764
14765   process_version_sections (file);
14766
14767   process_section_contents (file);
14768
14769   process_notes (file);
14770
14771   process_gnu_liblist (file);
14772
14773   process_arch_specific (file);
14774
14775   if (program_headers)
14776     {
14777       free (program_headers);
14778       program_headers = NULL;
14779     }
14780
14781   if (section_headers)
14782     {
14783       free (section_headers);
14784       section_headers = NULL;
14785     }
14786
14787   if (string_table)
14788     {
14789       free (string_table);
14790       string_table = NULL;
14791       string_table_length = 0;
14792     }
14793
14794   if (dynamic_strings)
14795     {
14796       free (dynamic_strings);
14797       dynamic_strings = NULL;
14798       dynamic_strings_length = 0;
14799     }
14800
14801   if (dynamic_symbols)
14802     {
14803       free (dynamic_symbols);
14804       dynamic_symbols = NULL;
14805       num_dynamic_syms = 0;
14806     }
14807
14808   if (dynamic_syminfo)
14809     {
14810       free (dynamic_syminfo);
14811       dynamic_syminfo = NULL;
14812     }
14813
14814   if (dynamic_section)
14815     {
14816       free (dynamic_section);
14817       dynamic_section = NULL;
14818     }
14819
14820   if (section_headers_groups)
14821     {
14822       free (section_headers_groups);
14823       section_headers_groups = NULL;
14824     }
14825
14826   if (section_groups)
14827     {
14828       struct group_list * g;
14829       struct group_list * next;
14830
14831       for (i = 0; i < group_count; i++)
14832         {
14833           for (g = section_groups [i].root; g != NULL; g = next)
14834             {
14835               next = g->next;
14836               free (g);
14837             }
14838         }
14839
14840       free (section_groups);
14841       section_groups = NULL;
14842     }
14843
14844   free_debug_memory ();
14845
14846   return 0;
14847 }
14848
14849 /* Process an ELF archive.
14850    On entry the file is positioned just after the ARMAG string.  */
14851
14852 static int
14853 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14854 {
14855   struct archive_info arch;
14856   struct archive_info nested_arch;
14857   size_t got;
14858   int ret;
14859
14860   show_name = 1;
14861
14862   /* The ARCH structure is used to hold information about this archive.  */
14863   arch.file_name = NULL;
14864   arch.file = NULL;
14865   arch.index_array = NULL;
14866   arch.sym_table = NULL;
14867   arch.longnames = NULL;
14868
14869   /* The NESTED_ARCH structure is used as a single-item cache of information
14870      about a nested archive (when members of a thin archive reside within
14871      another regular archive file).  */
14872   nested_arch.file_name = NULL;
14873   nested_arch.file = NULL;
14874   nested_arch.index_array = NULL;
14875   nested_arch.sym_table = NULL;
14876   nested_arch.longnames = NULL;
14877
14878   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14879     {
14880       ret = 1;
14881       goto out;
14882     }
14883
14884   if (do_archive_index)
14885     {
14886       if (arch.sym_table == NULL)
14887         error (_("%s: unable to dump the index as none was found\n"), file_name);
14888       else
14889         {
14890           unsigned int i, l;
14891           unsigned long current_pos;
14892
14893           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14894                   file_name, (long) arch.index_num, arch.sym_size);
14895           current_pos = ftell (file);
14896
14897           for (i = l = 0; i < arch.index_num; i++)
14898             {
14899               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14900                 {
14901                   char * member_name;
14902
14903                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14904
14905                   if (member_name != NULL)
14906                     {
14907                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14908
14909                       if (qualified_name != NULL)
14910                         {
14911                           printf (_("Contents of binary %s at offset "), qualified_name);
14912                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14913                           putchar ('\n');
14914                           free (qualified_name);
14915                         }
14916                     }
14917                 }
14918
14919               if (l >= arch.sym_size)
14920                 {
14921                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14922                          file_name);
14923                   break;
14924                 }
14925               printf ("\t%s\n", arch.sym_table + l);
14926               l += strlen (arch.sym_table + l) + 1;
14927             }
14928
14929           if (arch.uses_64bit_indicies)
14930             l = (l + 7) & ~ 7;
14931           else
14932             l += l & 1;
14933
14934           if (l < arch.sym_size)
14935             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14936                    file_name, arch.sym_size - l);
14937
14938           if (fseek (file, current_pos, SEEK_SET) != 0)
14939             {
14940               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14941               ret = 1;
14942               goto out;
14943             }
14944         }
14945
14946       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14947           && !do_segments && !do_header && !do_dump && !do_version
14948           && !do_histogram && !do_debugging && !do_arch && !do_notes
14949           && !do_section_groups && !do_dyn_syms)
14950         {
14951           ret = 0; /* Archive index only.  */
14952           goto out;
14953         }
14954     }
14955
14956   ret = 0;
14957
14958   while (1)
14959     {
14960       char * name;
14961       size_t namelen;
14962       char * qualified_name;
14963
14964       /* Read the next archive header.  */
14965       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14966         {
14967           error (_("%s: failed to seek to next archive header\n"), file_name);
14968           return 1;
14969         }
14970       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14971       if (got != sizeof arch.arhdr)
14972         {
14973           if (got == 0)
14974             break;
14975           error (_("%s: failed to read archive header\n"), file_name);
14976           ret = 1;
14977           break;
14978         }
14979       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14980         {
14981           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14982           ret = 1;
14983           break;
14984         }
14985
14986       arch.next_arhdr_offset += sizeof arch.arhdr;
14987
14988       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14989       if (archive_file_size & 01)
14990         ++archive_file_size;
14991
14992       name = get_archive_member_name (&arch, &nested_arch);
14993       if (name == NULL)
14994         {
14995           error (_("%s: bad archive file name\n"), file_name);
14996           ret = 1;
14997           break;
14998         }
14999       namelen = strlen (name);
15000
15001       qualified_name = make_qualified_name (&arch, &nested_arch, name);
15002       if (qualified_name == NULL)
15003         {
15004           error (_("%s: bad archive file name\n"), file_name);
15005           ret = 1;
15006           break;
15007         }
15008
15009       if (is_thin_archive && arch.nested_member_origin == 0)
15010         {
15011           /* This is a proxy for an external member of a thin archive.  */
15012           FILE * member_file;
15013           char * member_file_name = adjust_relative_path (file_name, name, namelen);
15014           if (member_file_name == NULL)
15015             {
15016               ret = 1;
15017               break;
15018             }
15019
15020           member_file = fopen (member_file_name, "rb");
15021           if (member_file == NULL)
15022             {
15023               error (_("Input file '%s' is not readable.\n"), member_file_name);
15024               free (member_file_name);
15025               ret = 1;
15026               break;
15027             }
15028
15029           archive_file_offset = arch.nested_member_origin;
15030
15031           ret |= process_object (qualified_name, member_file);
15032
15033           fclose (member_file);
15034           free (member_file_name);
15035         }
15036       else if (is_thin_archive)
15037         {
15038           /* PR 15140: Allow for corrupt thin archives.  */
15039           if (nested_arch.file == NULL)
15040             {
15041               error (_("%s: contains corrupt thin archive: %s\n"),
15042                      file_name, name);
15043               ret = 1;
15044               break;
15045             }
15046
15047           /* This is a proxy for a member of a nested archive.  */
15048           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15049
15050           /* The nested archive file will have been opened and setup by
15051              get_archive_member_name.  */
15052           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15053             {
15054               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15055               ret = 1;
15056               break;
15057             }
15058
15059           ret |= process_object (qualified_name, nested_arch.file);
15060         }
15061       else
15062         {
15063           archive_file_offset = arch.next_arhdr_offset;
15064           arch.next_arhdr_offset += archive_file_size;
15065
15066           ret |= process_object (qualified_name, file);
15067         }
15068
15069       if (dump_sects != NULL)
15070         {
15071           free (dump_sects);
15072           dump_sects = NULL;
15073           num_dump_sects = 0;
15074         }
15075
15076       free (qualified_name);
15077     }
15078
15079  out:
15080   if (nested_arch.file != NULL)
15081     fclose (nested_arch.file);
15082   release_archive (&nested_arch);
15083   release_archive (&arch);
15084
15085   return ret;
15086 }
15087
15088 static int
15089 process_file (char * file_name)
15090 {
15091   FILE * file;
15092   struct stat statbuf;
15093   char armag[SARMAG];
15094   int ret;
15095
15096   if (stat (file_name, &statbuf) < 0)
15097     {
15098       if (errno == ENOENT)
15099         error (_("'%s': No such file\n"), file_name);
15100       else
15101         error (_("Could not locate '%s'.  System error message: %s\n"),
15102                file_name, strerror (errno));
15103       return 1;
15104     }
15105
15106   if (! S_ISREG (statbuf.st_mode))
15107     {
15108       error (_("'%s' is not an ordinary file\n"), file_name);
15109       return 1;
15110     }
15111
15112   file = fopen (file_name, "rb");
15113   if (file == NULL)
15114     {
15115       error (_("Input file '%s' is not readable.\n"), file_name);
15116       return 1;
15117     }
15118
15119   if (fread (armag, SARMAG, 1, file) != 1)
15120     {
15121       error (_("%s: Failed to read file's magic number\n"), file_name);
15122       fclose (file);
15123       return 1;
15124     }
15125
15126   current_file_size = (bfd_size_type) statbuf.st_size;
15127
15128   if (memcmp (armag, ARMAG, SARMAG) == 0)
15129     ret = process_archive (file_name, file, FALSE);
15130   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15131     ret = process_archive (file_name, file, TRUE);
15132   else
15133     {
15134       if (do_archive_index)
15135         error (_("File %s is not an archive so its index cannot be displayed.\n"),
15136                file_name);
15137
15138       rewind (file);
15139       archive_file_size = archive_file_offset = 0;
15140       ret = process_object (file_name, file);
15141     }
15142
15143   fclose (file);
15144
15145   current_file_size = 0;
15146   return ret;
15147 }
15148
15149 #ifdef SUPPORT_DISASSEMBLY
15150 /* Needed by the i386 disassembler.  For extra credit, someone could
15151    fix this so that we insert symbolic addresses here, esp for GOT/PLT
15152    symbols.  */
15153
15154 void
15155 print_address (unsigned int addr, FILE * outfile)
15156 {
15157   fprintf (outfile,"0x%8.8x", addr);
15158 }
15159
15160 /* Needed by the i386 disassembler.  */
15161 void
15162 db_task_printsym (unsigned int addr)
15163 {
15164   print_address (addr, stderr);
15165 }
15166 #endif
15167
15168 int
15169 main (int argc, char ** argv)
15170 {
15171   int err;
15172
15173 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15174   setlocale (LC_MESSAGES, "");
15175 #endif
15176 #if defined (HAVE_SETLOCALE)
15177   setlocale (LC_CTYPE, "");
15178 #endif
15179   bindtextdomain (PACKAGE, LOCALEDIR);
15180   textdomain (PACKAGE);
15181
15182   expandargv (&argc, &argv);
15183
15184   parse_args (argc, argv);
15185
15186   if (num_dump_sects > 0)
15187     {
15188       /* Make a copy of the dump_sects array.  */
15189       cmdline_dump_sects = (dump_type *)
15190           malloc (num_dump_sects * sizeof (* dump_sects));
15191       if (cmdline_dump_sects == NULL)
15192         error (_("Out of memory allocating dump request table.\n"));
15193       else
15194         {
15195           memcpy (cmdline_dump_sects, dump_sects,
15196                   num_dump_sects * sizeof (* dump_sects));
15197           num_cmdline_dump_sects = num_dump_sects;
15198         }
15199     }
15200
15201   if (optind < (argc - 1))
15202     show_name = 1;
15203
15204   err = 0;
15205   while (optind < argc)
15206     err |= process_file (argv[optind++]);
15207
15208   if (dump_sects != NULL)
15209     free (dump_sects);
15210   if (cmdline_dump_sects != NULL)
15211     free (cmdline_dump_sects);
15212
15213   return err;
15214 }