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
 426   if (do_wide)
 427     /* Set the remaining width to a very large value.
 428        This simplifies the code below.  */
 429     width_remaining = INT_MAX;
 430   else
 431     width_remaining = width;
 432
 433 #ifdef HAVE_MBSTATE_T
 434   /* Initialise the multibyte conversion state.  */
 435   memset (& state, 0, sizeof (state));
 436 #endif
 437
 438   while (width_remaining)
 439     {
 440       size_t  n;
 441       const char c = *symbol++;
 442
 443       if (c == 0)
 444         break;
 445
 446       /* Do not print control characters directly as they can affect terminal
 447          settings.  Such characters usually appear in the names generated
 448          by the assembler for local labels.  */
 449       if (ISCNTRL (c))
 450         {
 451           if (width_remaining < 2)
 452             break;
 453
 454           printf ("^%c", c + 0x40);
 455           width_remaining -= 2;
 456           num_printed += 2;
 457         }
 458       else if (ISPRINT (c))
 459         {
 460           putchar (c);
 461           width_remaining --;
 462           num_printed ++;
 463         }
 464       else
 465         {
 466 #ifdef HAVE_MBSTATE_T
 467           wchar_t w;
 468 #endif
 469           /* Let printf do the hard work of displaying multibyte characters.  */
 470           printf ("%.1s", symbol - 1);
 471           width_remaining --;
 472           num_printed ++;
 473
 474 #ifdef HAVE_MBSTATE_T
 475           /* Try to find out how many bytes made up the character that was
 476              just printed.  Advance the symbol pointer past the bytes that
 477              were displayed.  */
 478           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 479 #else
 480           n = 1;
 481 #endif
 482           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 483             symbol += (n - 1);
 484         }
 485     }
 486
 487   if (extra_padding && num_printed < width)
 488     {
 489       /* Fill in the remaining spaces.  */
 490       printf ("%-*s", width - num_printed, " ");
 491       num_printed = width;
 492     }
 493
 494   return num_printed;
 495 }
 496
 497 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 498
 499 static Elf_Internal_Shdr *
 500 find_section (const char * name)
 501 {
 502   unsigned int i;
 503
 504   for (i = 0; i < elf_header.e_shnum; i++)
 505     if (streq (SECTION_NAME (section_headers + i), name))
 506       return section_headers + i;
 507
 508   return NULL;
 509 }
 510
 511 /* Return a pointer to a section containing ADDR, or NULL if no such
 512    section exists.  */
 513
 514 static Elf_Internal_Shdr *
 515 find_section_by_address (bfd_vma addr)
 516 {
 517   unsigned int i;
 518
 519   for (i = 0; i < elf_header.e_shnum; i++)
 520     {
 521       Elf_Internal_Shdr *sec = section_headers + i;
 522       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 523         return sec;
 524     }
 525
 526   return NULL;
 527 }
 528
 529 /* Return a pointer to section NAME, or NULL if no such section exists,
 530    restricted to the list of sections given in SET.  */
 531
 532 static Elf_Internal_Shdr *
 533 find_section_in_set (const char * name, unsigned int * set)
 534 {
 535   unsigned int i;
 536
 537   if (set != NULL)
 538     {
 539       while ((i = *set++) > 0)
 540         if (streq (SECTION_NAME (section_headers + i), name))
 541           return section_headers + i;
 542     }
 543
 544   return find_section (name);
 545 }
 546
 547 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 548    bytes read.  */
 549
 550 static inline unsigned long
 551 read_uleb128 (unsigned char *data,
 552               unsigned int *length_return,
 553               const unsigned char * const end)
 554 {
 555   return read_leb128 (data, length_return, FALSE, end);
 556 }
 557
 558 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 559    This OS has so many departures from the ELF standard that we test it at
 560    many places.  */
 561
 562 static inline int
 563 is_ia64_vms (void)
 564 {
 565   return elf_header.e_machine == EM_IA_64
 566     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 567 }
 568
 569 /* Guess the relocation size commonly used by the specific machines.  */
 570
 571 static int
 572 guess_is_rela (unsigned int e_machine)
 573 {
 574   switch (e_machine)
 575     {
 576       /* Targets that use REL relocations.  */
 577     case EM_386:
 578     case EM_486:
 579     case EM_960:
 580     case EM_ARM:
 581     case EM_D10V:
 582     case EM_CYGNUS_D10V:
 583     case EM_DLX:
 584     case EM_MIPS:
 585     case EM_MIPS_RS3_LE:
 586     case EM_CYGNUS_M32R:
 587     case EM_SCORE:
 588     case EM_XGATE:
 589       return FALSE;
 590
 591       /* Targets that use RELA relocations.  */
 592     case EM_68K:
 593     case EM_860:
 594     case EM_AARCH64:
 595     case EM_ADAPTEVA_EPIPHANY:
 596     case EM_ALPHA:
 597     case EM_ALTERA_NIOS2:
 598     case EM_AVR:
 599     case EM_AVR_OLD:
 600     case EM_BLACKFIN:
 601     case EM_CR16:
 602     case EM_CRIS:
 603     case EM_CRX:
 604     case EM_D30V:
 605     case EM_CYGNUS_D30V:
 606     case EM_FR30:
 607     case EM_CYGNUS_FR30:
 608     case EM_CYGNUS_FRV:
 609     case EM_H8S:
 610     case EM_H8_300:
 611     case EM_H8_300H:
 612     case EM_IA_64:
 613     case EM_IP2K:
 614     case EM_IP2K_OLD:
 615     case EM_IQ2000:
 616     case EM_LATTICEMICO32:
 617     case EM_M32C_OLD:
 618     case EM_M32C:
 619     case EM_M32R:
 620     case EM_MCORE:
 621     case EM_CYGNUS_MEP:
 622     case EM_METAG:
 623     case EM_MMIX:
 624     case EM_MN10200:
 625     case EM_CYGNUS_MN10200:
 626     case EM_MN10300:
 627     case EM_CYGNUS_MN10300:
 628     case EM_MOXIE:
 629     case EM_MSP430:
 630     case EM_MSP430_OLD:
 631     case EM_MT:
 632     case EM_NDS32:
 633     case EM_NIOS32:
 634     case EM_OR1K:
 635     case EM_PPC64:
 636     case EM_PPC:
 637     case EM_RL78:
 638     case EM_RX:
 639     case EM_S390:
 640     case EM_S390_OLD:
 641     case EM_SH:
 642     case EM_SPARC:
 643     case EM_SPARC32PLUS:
 644     case EM_SPARCV9:
 645     case EM_SPU:
 646     case EM_TI_C6000:
 647     case EM_TILEGX:
 648     case EM_TILEPRO:
 649     case EM_V800:
 650     case EM_V850:
 651     case EM_CYGNUS_V850:
 652     case EM_VAX:
 653     case EM_X86_64:
 654     case EM_L1OM:
 655     case EM_K1OM:
 656     case EM_XSTORMY16:
 657     case EM_XTENSA:
 658     case EM_XTENSA_OLD:
 659     case EM_MICROBLAZE:
 660     case EM_MICROBLAZE_OLD:
 661       return TRUE;
 662
 663     case EM_68HC05:
 664     case EM_68HC08:
 665     case EM_68HC11:
 666     case EM_68HC16:
 667     case EM_FX66:
 668     case EM_ME16:
 669     case EM_MMA:
 670     case EM_NCPU:
 671     case EM_NDR1:
 672     case EM_PCP:
 673     case EM_ST100:
 674     case EM_ST19:
 675     case EM_ST7:
 676     case EM_ST9PLUS:
 677     case EM_STARCORE:
 678     case EM_SVX:
 679     case EM_TINYJ:
 680     default:
 681       warn (_("Don't know about relocations on this machine architecture\n"));
 682       return FALSE;
 683     }
 684 }
 685
 686 static int
 687 slurp_rela_relocs (FILE * file,
 688                    unsigned long rel_offset,
 689                    unsigned long rel_size,
 690                    Elf_Internal_Rela ** relasp,
 691                    unsigned long * nrelasp)
 692 {
 693   Elf_Internal_Rela * relas;
 694   unsigned long nrelas;
 695   unsigned int i;
 696
 697   if (is_32bit_elf)
 698     {
 699       Elf32_External_Rela * erelas;
 700
 701       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 702                                                  rel_size, _("32-bit relocation data"));
 703       if (!erelas)
 704         return 0;
 705
 706       nrelas = rel_size / sizeof (Elf32_External_Rela);
 707
 708       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 709                                              sizeof (Elf_Internal_Rela));
 710
 711       if (relas == NULL)
 712         {
 713           free (erelas);
 714           error (_("out of memory parsing relocs\n"));
 715           return 0;
 716         }
 717
 718       for (i = 0; i < nrelas; i++)
 719         {
 720           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 721           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 722           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 723         }
 724
 725       free (erelas);
 726     }
 727   else
 728     {
 729       Elf64_External_Rela * erelas;
 730
 731       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 732                                                  rel_size, _("64-bit relocation data"));
 733       if (!erelas)
 734         return 0;
 735
 736       nrelas = rel_size / sizeof (Elf64_External_Rela);
 737
 738       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 739                                              sizeof (Elf_Internal_Rela));
 740
 741       if (relas == NULL)
 742         {
 743           free (erelas);
 744           error (_("out of memory parsing relocs\n"));
 745           return 0;
 746         }
 747
 748       for (i = 0; i < nrelas; i++)
 749         {
 750           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 751           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 752           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 753
 754           /* The #ifdef BFD64 below is to prevent a compile time
 755              warning.  We know that if we do not have a 64 bit data
 756              type that we will never execute this code anyway.  */
 757 #ifdef BFD64
 758           if (elf_header.e_machine == EM_MIPS
 759               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 760             {
 761               /* In little-endian objects, r_info isn't really a
 762                  64-bit little-endian value: it has a 32-bit
 763                  little-endian symbol index followed by four
 764                  individual byte fields.  Reorder INFO
 765                  accordingly.  */
 766               bfd_vma inf = relas[i].r_info;
 767               inf = (((inf & 0xffffffff) << 32)
 768                       | ((inf >> 56) & 0xff)
 769                       | ((inf >> 40) & 0xff00)
 770                       | ((inf >> 24) & 0xff0000)
 771                       | ((inf >> 8) & 0xff000000));
 772               relas[i].r_info = inf;
 773             }
 774 #endif /* BFD64 */
 775         }
 776
 777       free (erelas);
 778     }
 779   *relasp = relas;
 780   *nrelasp = nrelas;
 781   return 1;
 782 }
 783
 784 static int
 785 slurp_rel_relocs (FILE * file,
 786                   unsigned long rel_offset,
 787                   unsigned long rel_size,
 788                   Elf_Internal_Rela ** relsp,
 789                   unsigned long * nrelsp)
 790 {
 791   Elf_Internal_Rela * rels;
 792   unsigned long nrels;
 793   unsigned int i;
 794
 795   if (is_32bit_elf)
 796     {
 797       Elf32_External_Rel * erels;
 798
 799       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 800                                                rel_size, _("32-bit relocation data"));
 801       if (!erels)
 802         return 0;
 803
 804       nrels = rel_size / sizeof (Elf32_External_Rel);
 805
 806       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 807
 808       if (rels == NULL)
 809         {
 810           free (erels);
 811           error (_("out of memory parsing relocs\n"));
 812           return 0;
 813         }
 814
 815       for (i = 0; i < nrels; i++)
 816         {
 817           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 818           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 819           rels[i].r_addend = 0;
 820         }
 821
 822       free (erels);
 823     }
 824   else
 825     {
 826       Elf64_External_Rel * erels;
 827
 828       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 829                                                rel_size, _("64-bit relocation data"));
 830       if (!erels)
 831         return 0;
 832
 833       nrels = rel_size / sizeof (Elf64_External_Rel);
 834
 835       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 836
 837       if (rels == NULL)
 838         {
 839           free (erels);
 840           error (_("out of memory parsing relocs\n"));
 841           return 0;
 842         }
 843
 844       for (i = 0; i < nrels; i++)
 845         {
 846           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 847           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 848           rels[i].r_addend = 0;
 849
 850           /* The #ifdef BFD64 below is to prevent a compile time
 851              warning.  We know that if we do not have a 64 bit data
 852              type that we will never execute this code anyway.  */
 853 #ifdef BFD64
 854           if (elf_header.e_machine == EM_MIPS
 855               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 856             {
 857               /* In little-endian objects, r_info isn't really a
 858                  64-bit little-endian value: it has a 32-bit
 859                  little-endian symbol index followed by four
 860                  individual byte fields.  Reorder INFO
 861                  accordingly.  */
 862               bfd_vma inf = rels[i].r_info;
 863               inf = (((inf & 0xffffffff) << 32)
 864                      | ((inf >> 56) & 0xff)
 865                      | ((inf >> 40) & 0xff00)
 866                      | ((inf >> 24) & 0xff0000)
 867                      | ((inf >> 8) & 0xff000000));
 868               rels[i].r_info = inf;
 869             }
 870 #endif /* BFD64 */
 871         }
 872
 873       free (erels);
 874     }
 875   *relsp = rels;
 876   *nrelsp = nrels;
 877   return 1;
 878 }
 879
 880 /* Returns the reloc type extracted from the reloc info field.  */
 881
 882 static unsigned int
 883 get_reloc_type (bfd_vma reloc_info)
 884 {
 885   if (is_32bit_elf)
 886     return ELF32_R_TYPE (reloc_info);
 887
 888   switch (elf_header.e_machine)
 889     {
 890     case EM_MIPS:
 891       /* Note: We assume that reloc_info has already been adjusted for us.  */
 892       return ELF64_MIPS_R_TYPE (reloc_info);
 893
 894     case EM_SPARCV9:
 895       return ELF64_R_TYPE_ID (reloc_info);
 896
 897     default:
 898       return ELF64_R_TYPE (reloc_info);
 899     }
 900 }
 901
 902 /* Return the symbol index extracted from the reloc info field.  */
 903
 904 static bfd_vma
 905 get_reloc_symindex (bfd_vma reloc_info)
 906 {
 907   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 908 }
 909
 910 static inline bfd_boolean
 911 uses_msp430x_relocs (void)
 912 {
 913   return
 914     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 915     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 916     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 917         /* TI compiler uses ELFOSABI_NONE.  */
 918         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 919 }
 920
 921 /* Display the contents of the relocation data found at the specified
 922    offset.  */
 923
 924 static void
 925 dump_relocations (FILE * file,
 926                   unsigned long rel_offset,
 927                   unsigned long rel_size,
 928                   Elf_Internal_Sym * symtab,
 929                   unsigned long nsyms,
 930                   char * strtab,
 931                   unsigned long strtablen,
 932                   int is_rela)
 933 {
 934   unsigned int i;
 935   Elf_Internal_Rela * rels;
 936
 937   if (is_rela == UNKNOWN)
 938     is_rela = guess_is_rela (elf_header.e_machine);
 939
 940   if (is_rela)
 941     {
 942       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 943         return;
 944     }
 945   else
 946     {
 947       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 948         return;
 949     }
 950
 951   if (is_32bit_elf)
 952     {
 953       if (is_rela)
 954         {
 955           if (do_wide)
 956             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 957           else
 958             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 959         }
 960       else
 961         {
 962           if (do_wide)
 963             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 964           else
 965             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 966         }
 967     }
 968   else
 969     {
 970       if (is_rela)
 971         {
 972           if (do_wide)
 973             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 974           else
 975             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 976         }
 977       else
 978         {
 979           if (do_wide)
 980             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 981           else
 982             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 983         }
 984     }
 985
 986   for (i = 0; i < rel_size; i++)
 987     {
 988       const char * rtype;
 989       bfd_vma offset;
 990       bfd_vma inf;
 991       bfd_vma symtab_index;
 992       bfd_vma type;
 993
 994       offset = rels[i].r_offset;
 995       inf    = rels[i].r_info;
 996
 997       type = get_reloc_type (inf);
 998       symtab_index = get_reloc_symindex  (inf);
 999
1000       if (is_32bit_elf)
1001         {
1002           printf ("%8.8lx  %8.8lx ",
1003                   (unsigned long) offset & 0xffffffff,
1004                   (unsigned long) inf & 0xffffffff);
1005         }
1006       else
1007         {
1008 #if BFD_HOST_64BIT_LONG
1009           printf (do_wide
1010                   ? "%16.16lx  %16.16lx "
1011                   : "%12.12lx  %12.12lx ",
1012                   offset, inf);
1013 #elif BFD_HOST_64BIT_LONG_LONG
1014 #ifndef __MSVCRT__
1015           printf (do_wide
1016                   ? "%16.16llx  %16.16llx "
1017                   : "%12.12llx  %12.12llx ",
1018                   offset, inf);
1019 #else
1020           printf (do_wide
1021                   ? "%16.16I64x  %16.16I64x "
1022                   : "%12.12I64x  %12.12I64x ",
1023                   offset, inf);
1024 #endif
1025 #else
1026           printf (do_wide
1027                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1028                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1029                   _bfd_int64_high (offset),
1030                   _bfd_int64_low (offset),
1031                   _bfd_int64_high (inf),
1032                   _bfd_int64_low (inf));
1033 #endif
1034         }
1035
1036       switch (elf_header.e_machine)
1037         {
1038         default:
1039           rtype = NULL;
1040           break;
1041
1042         case EM_AARCH64:
1043           rtype = elf_aarch64_reloc_type (type);
1044           break;
1045
1046         case EM_M32R:
1047         case EM_CYGNUS_M32R:
1048           rtype = elf_m32r_reloc_type (type);
1049           break;
1050
1051         case EM_386:
1052         case EM_486:
1053           rtype = elf_i386_reloc_type (type);
1054           break;
1055
1056         case EM_68HC11:
1057         case EM_68HC12:
1058           rtype = elf_m68hc11_reloc_type (type);
1059           break;
1060
1061         case EM_68K:
1062           rtype = elf_m68k_reloc_type (type);
1063           break;
1064
1065         case EM_960:
1066           rtype = elf_i960_reloc_type (type);
1067           break;
1068
1069         case EM_AVR:
1070         case EM_AVR_OLD:
1071           rtype = elf_avr_reloc_type (type);
1072           break;
1073
1074         case EM_OLD_SPARCV9:
1075         case EM_SPARC32PLUS:
1076         case EM_SPARCV9:
1077         case EM_SPARC:
1078           rtype = elf_sparc_reloc_type (type);
1079           break;
1080
1081         case EM_SPU:
1082           rtype = elf_spu_reloc_type (type);
1083           break;
1084
1085         case EM_V800:
1086           rtype = v800_reloc_type (type);
1087           break;
1088         case EM_V850:
1089         case EM_CYGNUS_V850:
1090           rtype = v850_reloc_type (type);
1091           break;
1092
1093         case EM_D10V:
1094         case EM_CYGNUS_D10V:
1095           rtype = elf_d10v_reloc_type (type);
1096           break;
1097
1098         case EM_D30V:
1099         case EM_CYGNUS_D30V:
1100           rtype = elf_d30v_reloc_type (type);
1101           break;
1102
1103         case EM_DLX:
1104           rtype = elf_dlx_reloc_type (type);
1105           break;
1106
1107         case EM_SH:
1108           rtype = elf_sh_reloc_type (type);
1109           break;
1110
1111         case EM_MN10300:
1112         case EM_CYGNUS_MN10300:
1113           rtype = elf_mn10300_reloc_type (type);
1114           break;
1115
1116         case EM_MN10200:
1117         case EM_CYGNUS_MN10200:
1118           rtype = elf_mn10200_reloc_type (type);
1119           break;
1120
1121         case EM_FR30:
1122         case EM_CYGNUS_FR30:
1123           rtype = elf_fr30_reloc_type (type);
1124           break;
1125
1126         case EM_CYGNUS_FRV:
1127           rtype = elf_frv_reloc_type (type);
1128           break;
1129
1130         case EM_MCORE:
1131           rtype = elf_mcore_reloc_type (type);
1132           break;
1133
1134         case EM_MMIX:
1135           rtype = elf_mmix_reloc_type (type);
1136           break;
1137
1138         case EM_MOXIE:
1139           rtype = elf_moxie_reloc_type (type);
1140           break;
1141
1142         case EM_MSP430:
1143           if (uses_msp430x_relocs ())
1144             {
1145               rtype = elf_msp430x_reloc_type (type);
1146               break;
1147             }
1148         case EM_MSP430_OLD:
1149           rtype = elf_msp430_reloc_type (type);
1150           break;
1151
1152         case EM_NDS32:
1153           rtype = elf_nds32_reloc_type (type);
1154           break;
1155
1156         case EM_PPC:
1157           rtype = elf_ppc_reloc_type (type);
1158           break;
1159
1160         case EM_PPC64:
1161           rtype = elf_ppc64_reloc_type (type);
1162           break;
1163
1164         case EM_MIPS:
1165         case EM_MIPS_RS3_LE:
1166           rtype = elf_mips_reloc_type (type);
1167           break;
1168
1169         case EM_ALPHA:
1170           rtype = elf_alpha_reloc_type (type);
1171           break;
1172
1173         case EM_ARM:
1174           rtype = elf_arm_reloc_type (type);
1175           break;
1176
1177         case EM_ARC:
1178           rtype = elf_arc_reloc_type (type);
1179           break;
1180
1181         case EM_PARISC:
1182           rtype = elf_hppa_reloc_type (type);
1183           break;
1184
1185         case EM_H8_300:
1186         case EM_H8_300H:
1187         case EM_H8S:
1188           rtype = elf_h8_reloc_type (type);
1189           break;
1190
1191         case EM_OR1K:
1192           rtype = elf_or1k_reloc_type (type);
1193           break;
1194
1195         case EM_PJ:
1196         case EM_PJ_OLD:
1197           rtype = elf_pj_reloc_type (type);
1198           break;
1199         case EM_IA_64:
1200           rtype = elf_ia64_reloc_type (type);
1201           break;
1202
1203         case EM_CRIS:
1204           rtype = elf_cris_reloc_type (type);
1205           break;
1206
1207         case EM_860:
1208           rtype = elf_i860_reloc_type (type);
1209           break;
1210
1211         case EM_X86_64:
1212         case EM_L1OM:
1213         case EM_K1OM:
1214           rtype = elf_x86_64_reloc_type (type);
1215           break;
1216
1217         case EM_S370:
1218           rtype = i370_reloc_type (type);
1219           break;
1220
1221         case EM_S390_OLD:
1222         case EM_S390:
1223           rtype = elf_s390_reloc_type (type);
1224           break;
1225
1226         case EM_SCORE:
1227           rtype = elf_score_reloc_type (type);
1228           break;
1229
1230         case EM_XSTORMY16:
1231           rtype = elf_xstormy16_reloc_type (type);
1232           break;
1233
1234         case EM_CRX:
1235           rtype = elf_crx_reloc_type (type);
1236           break;
1237
1238         case EM_VAX:
1239           rtype = elf_vax_reloc_type (type);
1240           break;
1241
1242         case EM_ADAPTEVA_EPIPHANY:
1243           rtype = elf_epiphany_reloc_type (type);
1244           break;
1245
1246         case EM_IP2K:
1247         case EM_IP2K_OLD:
1248           rtype = elf_ip2k_reloc_type (type);
1249           break;
1250
1251         case EM_IQ2000:
1252           rtype = elf_iq2000_reloc_type (type);
1253           break;
1254
1255         case EM_XTENSA_OLD:
1256         case EM_XTENSA:
1257           rtype = elf_xtensa_reloc_type (type);
1258           break;
1259
1260         case EM_LATTICEMICO32:
1261           rtype = elf_lm32_reloc_type (type);
1262           break;
1263
1264         case EM_M32C_OLD:
1265         case EM_M32C:
1266           rtype = elf_m32c_reloc_type (type);
1267           break;
1268
1269         case EM_MT:
1270           rtype = elf_mt_reloc_type (type);
1271           break;
1272
1273         case EM_BLACKFIN:
1274           rtype = elf_bfin_reloc_type (type);
1275           break;
1276
1277         case EM_CYGNUS_MEP:
1278           rtype = elf_mep_reloc_type (type);
1279           break;
1280
1281         case EM_CR16:
1282           rtype = elf_cr16_reloc_type (type);
1283           break;
1284
1285         case EM_MICROBLAZE:
1286         case EM_MICROBLAZE_OLD:
1287           rtype = elf_microblaze_reloc_type (type);
1288           break;
1289
1290         case EM_RL78:
1291           rtype = elf_rl78_reloc_type (type);
1292           break;
1293
1294         case EM_RX:
1295           rtype = elf_rx_reloc_type (type);
1296           break;
1297
1298         case EM_METAG:
1299           rtype = elf_metag_reloc_type (type);
1300           break;
1301
1302         case EM_XC16X:
1303         case EM_C166:
1304           rtype = elf_xc16x_reloc_type (type);
1305           break;
1306
1307         case EM_TI_C6000:
1308           rtype = elf_tic6x_reloc_type (type);
1309           break;
1310
1311         case EM_TILEGX:
1312           rtype = elf_tilegx_reloc_type (type);
1313           break;
1314
1315         case EM_TILEPRO:
1316           rtype = elf_tilepro_reloc_type (type);
1317           break;
1318
1319         case EM_XGATE:
1320           rtype = elf_xgate_reloc_type (type);
1321           break;
1322
1323         case EM_ALTERA_NIOS2:
1324           rtype = elf_nios2_reloc_type (type);
1325           break;
1326         }
1327
1328       if (rtype == NULL)
1329         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1330       else
1331         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1332
1333       if (elf_header.e_machine == EM_ALPHA
1334           && rtype != NULL
1335           && streq (rtype, "R_ALPHA_LITUSE")
1336           && is_rela)
1337         {
1338           switch (rels[i].r_addend)
1339             {
1340             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1341             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1342             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1343             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1344             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1345             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1346             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1347             default: rtype = NULL;
1348             }
1349           if (rtype)
1350             printf (" (%s)", rtype);
1351           else
1352             {
1353               putchar (' ');
1354               printf (_("<unknown addend: %lx>"),
1355                       (unsigned long) rels[i].r_addend);
1356             }
1357         }
1358       else if (symtab_index)
1359         {
1360           if (symtab == NULL || symtab_index >= nsyms)
1361             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1362           else
1363             {
1364               Elf_Internal_Sym * psym;
1365
1366               psym = symtab + symtab_index;
1367
1368               printf (" ");
1369
1370               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1371                 {
1372                   const char * name;
1373                   unsigned int len;
1374                   unsigned int width = is_32bit_elf ? 8 : 14;
1375
1376                   /* Relocations against GNU_IFUNC symbols do not use the value
1377                      of the symbol as the address to relocate against.  Instead
1378                      they invoke the function named by the symbol and use its
1379                      result as the address for relocation.
1380
1381                      To indicate this to the user, do not display the value of
1382                      the symbol in the "Symbols's Value" field.  Instead show
1383                      its name followed by () as a hint that the symbol is
1384                      invoked.  */
1385
1386                   if (strtab == NULL
1387                       || psym->st_name == 0
1388                       || psym->st_name >= strtablen)
1389                     name = "??";
1390                   else
1391                     name = strtab + psym->st_name;
1392
1393                   len = print_symbol (width, name);
1394                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1395                 }
1396               else
1397                 {
1398                   print_vma (psym->st_value, LONG_HEX);
1399
1400                   printf (is_32bit_elf ? "   " : " ");
1401                 }
1402
1403               if (psym->st_name == 0)
1404                 {
1405                   const char * sec_name = "<null>";
1406                   char name_buf[40];
1407
1408                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1409                     {
1410                       if (psym->st_shndx < elf_header.e_shnum)
1411                         sec_name
1412                           = SECTION_NAME (section_headers + psym->st_shndx);
1413                       else if (psym->st_shndx == SHN_ABS)
1414                         sec_name = "ABS";
1415                       else if (psym->st_shndx == SHN_COMMON)
1416                         sec_name = "COMMON";
1417                       else if ((elf_header.e_machine == EM_MIPS
1418                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1419                                || (elf_header.e_machine == EM_TI_C6000
1420                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1421                         sec_name = "SCOMMON";
1422                       else if (elf_header.e_machine == EM_MIPS
1423                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1424                         sec_name = "SUNDEF";
1425                       else if ((elf_header.e_machine == EM_X86_64
1426                                 || elf_header.e_machine == EM_L1OM
1427                                 || elf_header.e_machine == EM_K1OM)
1428                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1429                         sec_name = "LARGE_COMMON";
1430                       else if (elf_header.e_machine == EM_IA_64
1431                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1432                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1433                         sec_name = "ANSI_COM";
1434                       else if (is_ia64_vms ()
1435                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1436                         sec_name = "VMS_SYMVEC";
1437                       else
1438                         {
1439                           sprintf (name_buf, "<section 0x%x>",
1440                                    (unsigned int) psym->st_shndx);
1441                           sec_name = name_buf;
1442                         }
1443                     }
1444                   print_symbol (22, sec_name);
1445                 }
1446               else if (strtab == NULL)
1447                 printf (_("<string table index: %3ld>"), psym->st_name);
1448               else if (psym->st_name >= strtablen)
1449                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1450               else
1451                 print_symbol (22, strtab + psym->st_name);
1452
1453               if (is_rela)
1454                 {
1455                   bfd_signed_vma off = rels[i].r_addend;
1456
1457                   if (off < 0)
1458                     printf (" - %" BFD_VMA_FMT "x", - off);
1459                   else
1460                     printf (" + %" BFD_VMA_FMT "x", off);
1461                 }
1462             }
1463         }
1464       else if (is_rela)
1465         {
1466           bfd_signed_vma off = rels[i].r_addend;
1467
1468           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1469           if (off < 0)
1470             printf ("-%" BFD_VMA_FMT "x", - off);
1471           else
1472             printf ("%" BFD_VMA_FMT "x", off);
1473         }
1474
1475       if (elf_header.e_machine == EM_SPARCV9
1476           && rtype != NULL
1477           && streq (rtype, "R_SPARC_OLO10"))
1478         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1479
1480       putchar ('\n');
1481
1482 #ifdef BFD64
1483       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1484         {
1485           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1486           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1487           const char * rtype2 = elf_mips_reloc_type (type2);
1488           const char * rtype3 = elf_mips_reloc_type (type3);
1489
1490           printf ("                    Type2: ");
1491
1492           if (rtype2 == NULL)
1493             printf (_("unrecognized: %-7lx"),
1494                     (unsigned long) type2 & 0xffffffff);
1495           else
1496             printf ("%-17.17s", rtype2);
1497
1498           printf ("\n                    Type3: ");
1499
1500           if (rtype3 == NULL)
1501             printf (_("unrecognized: %-7lx"),
1502                     (unsigned long) type3 & 0xffffffff);
1503           else
1504             printf ("%-17.17s", rtype3);
1505
1506           putchar ('\n');
1507         }
1508 #endif /* BFD64 */
1509     }
1510
1511   free (rels);
1512 }
1513
1514 static const char *
1515 get_mips_dynamic_type (unsigned long type)
1516 {
1517   switch (type)
1518     {
1519     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1520     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1521     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1522     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1523     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1524     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1525     case DT_MIPS_MSYM: return "MIPS_MSYM";
1526     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1527     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1528     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1529     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1530     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1531     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1532     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1533     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1534     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1535     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1536     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1537     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1538     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1539     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1540     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1541     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1542     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1543     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1544     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1545     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1546     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1547     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1548     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1549     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1550     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1551     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1552     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1553     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1554     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1555     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1556     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1557     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1558     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1559     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1560     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1561     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1562     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1563     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1564     default:
1565       return NULL;
1566     }
1567 }
1568
1569 static const char *
1570 get_sparc64_dynamic_type (unsigned long type)
1571 {
1572   switch (type)
1573     {
1574     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1575     default:
1576       return NULL;
1577     }
1578 }
1579
1580 static const char *
1581 get_ppc_dynamic_type (unsigned long type)
1582 {
1583   switch (type)
1584     {
1585     case DT_PPC_GOT:    return "PPC_GOT";
1586     case DT_PPC_OPT:    return "PPC_OPT";
1587     default:
1588       return NULL;
1589     }
1590 }
1591
1592 static const char *
1593 get_ppc64_dynamic_type (unsigned long type)
1594 {
1595   switch (type)
1596     {
1597     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1598     case DT_PPC64_OPD:    return "PPC64_OPD";
1599     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1600     case DT_PPC64_OPT:    return "PPC64_OPT";
1601     default:
1602       return NULL;
1603     }
1604 }
1605
1606 static const char *
1607 get_parisc_dynamic_type (unsigned long type)
1608 {
1609   switch (type)
1610     {
1611     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1612     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1613     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1614     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1615     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1616     case DT_HP_PREINIT:         return "HP_PREINIT";
1617     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1618     case DT_HP_NEEDED:          return "HP_NEEDED";
1619     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1620     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1621     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1622     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1623     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1624     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1625     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1626     case DT_HP_FILTERED:        return "HP_FILTERED";
1627     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1628     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1629     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1630     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1631     case DT_PLT:                return "PLT";
1632     case DT_PLT_SIZE:           return "PLT_SIZE";
1633     case DT_DLT:                return "DLT";
1634     case DT_DLT_SIZE:           return "DLT_SIZE";
1635     default:
1636       return NULL;
1637     }
1638 }
1639
1640 static const char *
1641 get_ia64_dynamic_type (unsigned long type)
1642 {
1643   switch (type)
1644     {
1645     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1646     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1647     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1648     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1649     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1650     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1651     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1652     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1653     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1654     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1655     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1656     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1657     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1658     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1659     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1660     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1661     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1662     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1663     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1664     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1665     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1666     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1667     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1668     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1669     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1670     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1671     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1672     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1673     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1674     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1675     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1676     default:
1677       return NULL;
1678     }
1679 }
1680
1681 static const char *
1682 get_alpha_dynamic_type (unsigned long type)
1683 {
1684   switch (type)
1685     {
1686     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1687     default:
1688       return NULL;
1689     }
1690 }
1691
1692 static const char *
1693 get_score_dynamic_type (unsigned long type)
1694 {
1695   switch (type)
1696     {
1697     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1698     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1699     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1700     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1701     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1702     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1703     default:
1704       return NULL;
1705     }
1706 }
1707
1708 static const char *
1709 get_tic6x_dynamic_type (unsigned long type)
1710 {
1711   switch (type)
1712     {
1713     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1714     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1715     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1716     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1717     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1718     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1719     default:
1720       return NULL;
1721     }
1722 }
1723
1724 static const char *
1725 get_nios2_dynamic_type (unsigned long type)
1726 {
1727   switch (type)
1728     {
1729     case DT_NIOS2_GP: return "NIOS2_GP";
1730     default:
1731       return NULL;
1732     }
1733 }
1734
1735 static const char *
1736 get_dynamic_type (unsigned long type)
1737 {
1738   static char buff[64];
1739
1740   switch (type)
1741     {
1742     case DT_NULL:       return "NULL";
1743     case DT_NEEDED:     return "NEEDED";
1744     case DT_PLTRELSZ:   return "PLTRELSZ";
1745     case DT_PLTGOT:     return "PLTGOT";
1746     case DT_HASH:       return "HASH";
1747     case DT_STRTAB:     return "STRTAB";
1748     case DT_SYMTAB:     return "SYMTAB";
1749     case DT_RELA:       return "RELA";
1750     case DT_RELASZ:     return "RELASZ";
1751     case DT_RELAENT:    return "RELAENT";
1752     case DT_STRSZ:      return "STRSZ";
1753     case DT_SYMENT:     return "SYMENT";
1754     case DT_INIT:       return "INIT";
1755     case DT_FINI:       return "FINI";
1756     case DT_SONAME:     return "SONAME";
1757     case DT_RPATH:      return "RPATH";
1758     case DT_SYMBOLIC:   return "SYMBOLIC";
1759     case DT_REL:        return "REL";
1760     case DT_RELSZ:      return "RELSZ";
1761     case DT_RELENT:     return "RELENT";
1762     case DT_PLTREL:     return "PLTREL";
1763     case DT_DEBUG:      return "DEBUG";
1764     case DT_TEXTREL:    return "TEXTREL";
1765     case DT_JMPREL:     return "JMPREL";
1766     case DT_BIND_NOW:   return "BIND_NOW";
1767     case DT_INIT_ARRAY: return "INIT_ARRAY";
1768     case DT_FINI_ARRAY: return "FINI_ARRAY";
1769     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1770     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1771     case DT_RUNPATH:    return "RUNPATH";
1772     case DT_FLAGS:      return "FLAGS";
1773
1774     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1775     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1776
1777     case DT_CHECKSUM:   return "CHECKSUM";
1778     case DT_PLTPADSZ:   return "PLTPADSZ";
1779     case DT_MOVEENT:    return "MOVEENT";
1780     case DT_MOVESZ:     return "MOVESZ";
1781     case DT_FEATURE:    return "FEATURE";
1782     case DT_POSFLAG_1:  return "POSFLAG_1";
1783     case DT_SYMINSZ:    return "SYMINSZ";
1784     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1785
1786     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1787     case DT_CONFIG:     return "CONFIG";
1788     case DT_DEPAUDIT:   return "DEPAUDIT";
1789     case DT_AUDIT:      return "AUDIT";
1790     case DT_PLTPAD:     return "PLTPAD";
1791     case DT_MOVETAB:    return "MOVETAB";
1792     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1793
1794     case DT_VERSYM:     return "VERSYM";
1795
1796     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1797     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1798     case DT_RELACOUNT:  return "RELACOUNT";
1799     case DT_RELCOUNT:   return "RELCOUNT";
1800     case DT_FLAGS_1:    return "FLAGS_1";
1801     case DT_VERDEF:     return "VERDEF";
1802     case DT_VERDEFNUM:  return "VERDEFNUM";
1803     case DT_VERNEED:    return "VERNEED";
1804     case DT_VERNEEDNUM: return "VERNEEDNUM";
1805
1806     case DT_AUXILIARY:  return "AUXILIARY";
1807     case DT_USED:       return "USED";
1808     case DT_FILTER:     return "FILTER";
1809
1810     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1811     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1812     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1813     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1814     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1815     case DT_GNU_HASH:   return "GNU_HASH";
1816
1817     default:
1818       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1819         {
1820           const char * result;
1821
1822           switch (elf_header.e_machine)
1823             {
1824             case EM_MIPS:
1825             case EM_MIPS_RS3_LE:
1826               result = get_mips_dynamic_type (type);
1827               break;
1828             case EM_SPARCV9:
1829               result = get_sparc64_dynamic_type (type);
1830               break;
1831             case EM_PPC:
1832               result = get_ppc_dynamic_type (type);
1833               break;
1834             case EM_PPC64:
1835               result = get_ppc64_dynamic_type (type);
1836               break;
1837             case EM_IA_64:
1838               result = get_ia64_dynamic_type (type);
1839               break;
1840             case EM_ALPHA:
1841               result = get_alpha_dynamic_type (type);
1842               break;
1843             case EM_SCORE:
1844               result = get_score_dynamic_type (type);
1845               break;
1846             case EM_TI_C6000:
1847               result = get_tic6x_dynamic_type (type);
1848               break;
1849             case EM_ALTERA_NIOS2:
1850               result = get_nios2_dynamic_type (type);
1851               break;
1852             default:
1853               result = NULL;
1854               break;
1855             }
1856
1857           if (result != NULL)
1858             return result;
1859
1860           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1861         }
1862       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1863                || (elf_header.e_machine == EM_PARISC
1864                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1865         {
1866           const char * result;
1867
1868           switch (elf_header.e_machine)
1869             {
1870             case EM_PARISC:
1871               result = get_parisc_dynamic_type (type);
1872               break;
1873             case EM_IA_64:
1874               result = get_ia64_dynamic_type (type);
1875               break;
1876             default:
1877               result = NULL;
1878               break;
1879             }
1880
1881           if (result != NULL)
1882             return result;
1883
1884           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1885                     type);
1886         }
1887       else
1888         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1889
1890       return buff;
1891     }
1892 }
1893
1894 static char *
1895 get_file_type (unsigned e_type)
1896 {
1897   static char buff[32];
1898
1899   switch (e_type)
1900     {
1901     case ET_NONE:       return _("NONE (None)");
1902     case ET_REL:        return _("REL (Relocatable file)");
1903     case ET_EXEC:       return _("EXEC (Executable file)");
1904     case ET_DYN:        return _("DYN (Shared object file)");
1905     case ET_CORE:       return _("CORE (Core file)");
1906
1907     default:
1908       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1909         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1910       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1911         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1912       else
1913         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1914       return buff;
1915     }
1916 }
1917
1918 static char *
1919 get_machine_name (unsigned e_machine)
1920 {
1921   static char buff[64]; /* XXX */
1922
1923   switch (e_machine)
1924     {
1925     case EM_NONE:               return _("None");
1926     case EM_AARCH64:            return "AArch64";
1927     case EM_M32:                return "WE32100";
1928     case EM_SPARC:              return "Sparc";
1929     case EM_SPU:                return "SPU";
1930     case EM_386:                return "Intel 80386";
1931     case EM_68K:                return "MC68000";
1932     case EM_88K:                return "MC88000";
1933     case EM_486:                return "Intel 80486";
1934     case EM_860:                return "Intel 80860";
1935     case EM_MIPS:               return "MIPS R3000";
1936     case EM_S370:               return "IBM System/370";
1937     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1938     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1939     case EM_PARISC:             return "HPPA";
1940     case EM_PPC_OLD:            return "Power PC (old)";
1941     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1942     case EM_960:                return "Intel 90860";
1943     case EM_PPC:                return "PowerPC";
1944     case EM_PPC64:              return "PowerPC64";
1945     case EM_FR20:               return "Fujitsu FR20";
1946     case EM_RH32:               return "TRW RH32";
1947     case EM_MCORE:              return "MCORE";
1948     case EM_ARM:                return "ARM";
1949     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1950     case EM_SH:                 return "Renesas / SuperH SH";
1951     case EM_SPARCV9:            return "Sparc v9";
1952     case EM_TRICORE:            return "Siemens Tricore";
1953     case EM_ARC:                return "ARC";
1954     case EM_H8_300:             return "Renesas H8/300";
1955     case EM_H8_300H:            return "Renesas H8/300H";
1956     case EM_H8S:                return "Renesas H8S";
1957     case EM_H8_500:             return "Renesas H8/500";
1958     case EM_IA_64:              return "Intel IA-64";
1959     case EM_MIPS_X:             return "Stanford MIPS-X";
1960     case EM_COLDFIRE:           return "Motorola Coldfire";
1961     case EM_ALPHA:              return "Alpha";
1962     case EM_CYGNUS_D10V:
1963     case EM_D10V:               return "d10v";
1964     case EM_CYGNUS_D30V:
1965     case EM_D30V:               return "d30v";
1966     case EM_CYGNUS_M32R:
1967     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1968     case EM_CYGNUS_V850:
1969     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1970     case EM_V850:               return "Renesas V850";
1971     case EM_CYGNUS_MN10300:
1972     case EM_MN10300:            return "mn10300";
1973     case EM_CYGNUS_MN10200:
1974     case EM_MN10200:            return "mn10200";
1975     case EM_MOXIE:              return "Moxie";
1976     case EM_CYGNUS_FR30:
1977     case EM_FR30:               return "Fujitsu FR30";
1978     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1979     case EM_PJ_OLD:
1980     case EM_PJ:                 return "picoJava";
1981     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1982     case EM_PCP:                return "Siemens PCP";
1983     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1984     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1985     case EM_STARCORE:           return "Motorola Star*Core processor";
1986     case EM_ME16:               return "Toyota ME16 processor";
1987     case EM_ST100:              return "STMicroelectronics ST100 processor";
1988     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1989     case EM_PDSP:               return "Sony DSP processor";
1990     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1991     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1992     case EM_FX66:               return "Siemens FX66 microcontroller";
1993     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1994     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1995     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1996     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1997     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1998     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1999     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2000     case EM_SVX:                return "Silicon Graphics SVx";
2001     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2002     case EM_VAX:                return "Digital VAX";
2003     case EM_AVR_OLD:
2004     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2005     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2006     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2007     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2008     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2009     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2010     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2011     case EM_PRISM:              return "Vitesse Prism";
2012     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2013     case EM_L1OM:               return "Intel L1OM";
2014     case EM_K1OM:               return "Intel K1OM";
2015     case EM_S390_OLD:
2016     case EM_S390:               return "IBM S/390";
2017     case EM_SCORE:              return "SUNPLUS S+Core";
2018     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2019     case EM_OR1K:               return "OpenRISC 1000";
2020     case EM_ARC_A5:             return "ARC International ARCompact processor";
2021     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2022     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2023     case EM_DLX:                return "OpenDLX";
2024     case EM_IP2K_OLD:
2025     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2026     case EM_IQ2000:             return "Vitesse IQ2000";
2027     case EM_XTENSA_OLD:
2028     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2029     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2030     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2031     case EM_NS32K:              return "National Semiconductor 32000 series";
2032     case EM_TPC:                return "Tenor Network TPC processor";
2033     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2034     case EM_MAX:                return "MAX Processor";
2035     case EM_CR:                 return "National Semiconductor CompactRISC";
2036     case EM_F2MC16:             return "Fujitsu F2MC16";
2037     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2038     case EM_LATTICEMICO32:      return "Lattice Mico32";
2039     case EM_M32C_OLD:
2040     case EM_M32C:               return "Renesas M32c";
2041     case EM_MT:                 return "Morpho Techologies MT processor";
2042     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2043     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2044     case EM_SEP:                return "Sharp embedded microprocessor";
2045     case EM_ARCA:               return "Arca RISC microprocessor";
2046     case EM_UNICORE:            return "Unicore";
2047     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2048     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2049     case EM_NIOS32:             return "Altera Nios";
2050     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2051     case EM_C166:
2052     case EM_XC16X:              return "Infineon Technologies xc16x";
2053     case EM_M16C:               return "Renesas M16C series microprocessors";
2054     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2055     case EM_CE:                 return "Freescale Communication Engine RISC core";
2056     case EM_TSK3000:            return "Altium TSK3000 core";
2057     case EM_RS08:               return "Freescale RS08 embedded processor";
2058     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2059     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2060     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2061     case EM_SE_C17:             return "Seiko Epson C17 family";
2062     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2063     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2064     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2065     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2066     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2067     case EM_R32C:               return "Renesas R32C series microprocessors";
2068     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2069     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2070     case EM_8051:               return "Intel 8051 and variants";
2071     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2072     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2073     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2074     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2075     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2076     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2077     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2078     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2079     case EM_CR16:
2080     case EM_MICROBLAZE:
2081     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2082     case EM_RL78:               return "Renesas RL78";
2083     case EM_RX:                 return "Renesas RX";
2084     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2085     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2086     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2087     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2088     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2089     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2090     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2091     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2092     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2093     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2094     case EM_CUDA:               return "NVIDIA CUDA architecture";
2095     case EM_XGATE:              return "Motorola XGATE embedded processor";
2096     default:
2097       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2098       return buff;
2099     }
2100 }
2101
2102 static void
2103 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2104 {
2105   unsigned eabi;
2106   int unknown = 0;
2107
2108   eabi = EF_ARM_EABI_VERSION (e_flags);
2109   e_flags &= ~ EF_ARM_EABIMASK;
2110
2111   /* Handle "generic" ARM flags.  */
2112   if (e_flags & EF_ARM_RELEXEC)
2113     {
2114       strcat (buf, ", relocatable executable");
2115       e_flags &= ~ EF_ARM_RELEXEC;
2116     }
2117
2118   if (e_flags & EF_ARM_HASENTRY)
2119     {
2120       strcat (buf, ", has entry point");
2121       e_flags &= ~ EF_ARM_HASENTRY;
2122     }
2123
2124   /* Now handle EABI specific flags.  */
2125   switch (eabi)
2126     {
2127     default:
2128       strcat (buf, ", <unrecognized EABI>");
2129       if (e_flags)
2130         unknown = 1;
2131       break;
2132
2133     case EF_ARM_EABI_VER1:
2134       strcat (buf, ", Version1 EABI");
2135       while (e_flags)
2136         {
2137           unsigned flag;
2138
2139           /* Process flags one bit at a time.  */
2140           flag = e_flags & - e_flags;
2141           e_flags &= ~ flag;
2142
2143           switch (flag)
2144             {
2145             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2146               strcat (buf, ", sorted symbol tables");
2147               break;
2148
2149             default:
2150               unknown = 1;
2151               break;
2152             }
2153         }
2154       break;
2155
2156     case EF_ARM_EABI_VER2:
2157       strcat (buf, ", Version2 EABI");
2158       while (e_flags)
2159         {
2160           unsigned flag;
2161
2162           /* Process flags one bit at a time.  */
2163           flag = e_flags & - e_flags;
2164           e_flags &= ~ flag;
2165
2166           switch (flag)
2167             {
2168             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2169               strcat (buf, ", sorted symbol tables");
2170               break;
2171
2172             case EF_ARM_DYNSYMSUSESEGIDX:
2173               strcat (buf, ", dynamic symbols use segment index");
2174               break;
2175
2176             case EF_ARM_MAPSYMSFIRST:
2177               strcat (buf, ", mapping symbols precede others");
2178               break;
2179
2180             default:
2181               unknown = 1;
2182               break;
2183             }
2184         }
2185       break;
2186
2187     case EF_ARM_EABI_VER3:
2188       strcat (buf, ", Version3 EABI");
2189       break;
2190
2191     case EF_ARM_EABI_VER4:
2192       strcat (buf, ", Version4 EABI");
2193       while (e_flags)
2194         {
2195           unsigned flag;
2196
2197           /* Process flags one bit at a time.  */
2198           flag = e_flags & - e_flags;
2199           e_flags &= ~ flag;
2200
2201           switch (flag)
2202             {
2203             case EF_ARM_BE8:
2204               strcat (buf, ", BE8");
2205               break;
2206
2207             case EF_ARM_LE8:
2208               strcat (buf, ", LE8");
2209               break;
2210
2211             default:
2212               unknown = 1;
2213               break;
2214             }
2215       break;
2216         }
2217       break;
2218
2219     case EF_ARM_EABI_VER5:
2220       strcat (buf, ", Version5 EABI");
2221       while (e_flags)
2222         {
2223           unsigned flag;
2224
2225           /* Process flags one bit at a time.  */
2226           flag = e_flags & - e_flags;
2227           e_flags &= ~ flag;
2228
2229           switch (flag)
2230             {
2231             case EF_ARM_BE8:
2232               strcat (buf, ", BE8");
2233               break;
2234
2235             case EF_ARM_LE8:
2236               strcat (buf, ", LE8");
2237               break;
2238
2239             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2240               strcat (buf, ", soft-float ABI");
2241               break;
2242
2243             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2244               strcat (buf, ", hard-float ABI");
2245               break;
2246
2247             default:
2248               unknown = 1;
2249               break;
2250             }
2251         }
2252       break;
2253
2254     case EF_ARM_EABI_UNKNOWN:
2255       strcat (buf, ", GNU EABI");
2256       while (e_flags)
2257         {
2258           unsigned flag;
2259
2260           /* Process flags one bit at a time.  */
2261           flag = e_flags & - e_flags;
2262           e_flags &= ~ flag;
2263
2264           switch (flag)
2265             {
2266             case EF_ARM_INTERWORK:
2267               strcat (buf, ", interworking enabled");
2268               break;
2269
2270             case EF_ARM_APCS_26:
2271               strcat (buf, ", uses APCS/26");
2272               break;
2273
2274             case EF_ARM_APCS_FLOAT:
2275               strcat (buf, ", uses APCS/float");
2276               break;
2277
2278             case EF_ARM_PIC:
2279               strcat (buf, ", position independent");
2280               break;
2281
2282             case EF_ARM_ALIGN8:
2283               strcat (buf, ", 8 bit structure alignment");
2284               break;
2285
2286             case EF_ARM_NEW_ABI:
2287               strcat (buf, ", uses new ABI");
2288               break;
2289
2290             case EF_ARM_OLD_ABI:
2291               strcat (buf, ", uses old ABI");
2292               break;
2293
2294             case EF_ARM_SOFT_FLOAT:
2295               strcat (buf, ", software FP");
2296               break;
2297
2298             case EF_ARM_VFP_FLOAT:
2299               strcat (buf, ", VFP");
2300               break;
2301
2302             case EF_ARM_MAVERICK_FLOAT:
2303               strcat (buf, ", Maverick FP");
2304               break;
2305
2306             default:
2307               unknown = 1;
2308               break;
2309             }
2310         }
2311     }
2312
2313   if (unknown)
2314     strcat (buf,_(", <unknown>"));
2315 }
2316
2317 static void
2318 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2319 {
2320   unsigned abi;
2321   unsigned arch;
2322   unsigned config;
2323   unsigned version;
2324   int has_fpu = 0;
2325   int r = 0;
2326
2327   static const char *ABI_STRINGS[] =
2328   {
2329     "ABI v0", /* use r5 as return register; only used in N1213HC */
2330     "ABI v1", /* use r0 as return register */
2331     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2332     "ABI v2fp", /* for FPU */
2333     "AABI",
2334     "ABI2 FP+"
2335   };
2336   static const char *VER_STRINGS[] =
2337   {
2338     "Andes ELF V1.3 or older",
2339     "Andes ELF V1.3.1",
2340     "Andes ELF V1.4"
2341   };
2342   static const char *ARCH_STRINGS[] =
2343   {
2344     "",
2345     "Andes Star v1.0",
2346     "Andes Star v2.0",
2347     "Andes Star v3.0",
2348     "Andes Star v3.0m"
2349   };
2350
2351   abi = EF_NDS_ABI & e_flags;
2352   arch = EF_NDS_ARCH & e_flags;
2353   config = EF_NDS_INST & e_flags;
2354   version = EF_NDS32_ELF_VERSION & e_flags;
2355
2356   memset (buf, 0, size);
2357
2358   switch (abi)
2359     {
2360     case E_NDS_ABI_V0:
2361     case E_NDS_ABI_V1:
2362     case E_NDS_ABI_V2:
2363     case E_NDS_ABI_V2FP:
2364     case E_NDS_ABI_AABI:
2365     case E_NDS_ABI_V2FP_PLUS:
2366       /* In case there are holes in the array.  */
2367       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2368       break;
2369
2370     default:
2371       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2372       break;
2373     }
2374
2375   switch (version)
2376     {
2377     case E_NDS32_ELF_VER_1_2:
2378     case E_NDS32_ELF_VER_1_3:
2379     case E_NDS32_ELF_VER_1_4:
2380       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2381       break;
2382
2383     default:
2384       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2385       break;
2386     }
2387
2388   if (E_NDS_ABI_V0 == abi)
2389     {
2390       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2391       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2392       if (arch == E_NDS_ARCH_STAR_V1_0)
2393         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2394       return;
2395     }
2396
2397   switch (arch)
2398     {
2399     case E_NDS_ARCH_STAR_V1_0:
2400     case E_NDS_ARCH_STAR_V2_0:
2401     case E_NDS_ARCH_STAR_V3_0:
2402     case E_NDS_ARCH_STAR_V3_M:
2403       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2404       break;
2405
2406     default:
2407       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2408       /* ARCH version determines how the e_flags are interpreted.
2409          If it is unknown, we cannot proceed.  */
2410       return;
2411     }
2412
2413   /* Newer ABI; Now handle architecture specific flags.  */
2414   if (arch == E_NDS_ARCH_STAR_V1_0)
2415     {
2416       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2417         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2418
2419       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2420         r += snprintf (buf + r, size -r, ", MAC");
2421
2422       if (config & E_NDS32_HAS_DIV_INST)
2423         r += snprintf (buf + r, size -r, ", DIV");
2424
2425       if (config & E_NDS32_HAS_16BIT_INST)
2426         r += snprintf (buf + r, size -r, ", 16b");
2427     }
2428   else
2429     {
2430       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2431         {
2432           if (version <= E_NDS32_ELF_VER_1_3)
2433             r += snprintf (buf + r, size -r, ", [B8]");
2434           else
2435             r += snprintf (buf + r, size -r, ", EX9");
2436         }
2437
2438       if (config & E_NDS32_HAS_MAC_DX_INST)
2439         r += snprintf (buf + r, size -r, ", MAC_DX");
2440
2441       if (config & E_NDS32_HAS_DIV_DX_INST)
2442         r += snprintf (buf + r, size -r, ", DIV_DX");
2443
2444       if (config & E_NDS32_HAS_16BIT_INST)
2445         {
2446           if (version <= E_NDS32_ELF_VER_1_3)
2447             r += snprintf (buf + r, size -r, ", 16b");
2448           else
2449             r += snprintf (buf + r, size -r, ", IFC");
2450         }
2451     }
2452
2453   if (config & E_NDS32_HAS_EXT_INST)
2454     r += snprintf (buf + r, size -r, ", PERF1");
2455
2456   if (config & E_NDS32_HAS_EXT2_INST)
2457     r += snprintf (buf + r, size -r, ", PERF2");
2458
2459   if (config & E_NDS32_HAS_FPU_INST)
2460     {
2461       has_fpu = 1;
2462       r += snprintf (buf + r, size -r, ", FPU_SP");
2463     }
2464
2465   if (config & E_NDS32_HAS_FPU_DP_INST)
2466     {
2467       has_fpu = 1;
2468       r += snprintf (buf + r, size -r, ", FPU_DP");
2469     }
2470
2471   if (config & E_NDS32_HAS_FPU_MAC_INST)
2472     {
2473       has_fpu = 1;
2474       r += snprintf (buf + r, size -r, ", FPU_MAC");
2475     }
2476
2477   if (has_fpu)
2478     {
2479       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2480         {
2481         case E_NDS32_FPU_REG_8SP_4DP:
2482           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2483           break;
2484         case E_NDS32_FPU_REG_16SP_8DP:
2485           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2486           break;
2487         case E_NDS32_FPU_REG_32SP_16DP:
2488           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2489           break;
2490         case E_NDS32_FPU_REG_32SP_32DP:
2491           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2492           break;
2493         }
2494     }
2495
2496   if (config & E_NDS32_HAS_AUDIO_INST)
2497     r += snprintf (buf + r, size -r, ", AUDIO");
2498
2499   if (config & E_NDS32_HAS_STRING_INST)
2500     r += snprintf (buf + r, size -r, ", STR");
2501
2502   if (config & E_NDS32_HAS_REDUCED_REGS)
2503     r += snprintf (buf + r, size -r, ", 16REG");
2504
2505   if (config & E_NDS32_HAS_VIDEO_INST)
2506     {
2507       if (version <= E_NDS32_ELF_VER_1_3)
2508         r += snprintf (buf + r, size -r, ", VIDEO");
2509       else
2510         r += snprintf (buf + r, size -r, ", SATURATION");
2511     }
2512
2513   if (config & E_NDS32_HAS_ENCRIPT_INST)
2514     r += snprintf (buf + r, size -r, ", ENCRP");
2515
2516   if (config & E_NDS32_HAS_L2C_INST)
2517     r += snprintf (buf + r, size -r, ", L2C");
2518 }
2519
2520 static char *
2521 get_machine_flags (unsigned e_flags, unsigned e_machine)
2522 {
2523   static char buf[1024];
2524
2525   buf[0] = '\0';
2526
2527   if (e_flags)
2528     {
2529       switch (e_machine)
2530         {
2531         default:
2532           break;
2533
2534         case EM_ARM:
2535           decode_ARM_machine_flags (e_flags, buf);
2536           break;
2537
2538         case EM_BLACKFIN:
2539           if (e_flags & EF_BFIN_PIC)
2540             strcat (buf, ", PIC");
2541
2542           if (e_flags & EF_BFIN_FDPIC)
2543             strcat (buf, ", FDPIC");
2544
2545           if (e_flags & EF_BFIN_CODE_IN_L1)
2546             strcat (buf, ", code in L1");
2547
2548           if (e_flags & EF_BFIN_DATA_IN_L1)
2549             strcat (buf, ", data in L1");
2550
2551           break;
2552
2553         case EM_CYGNUS_FRV:
2554           switch (e_flags & EF_FRV_CPU_MASK)
2555             {
2556             case EF_FRV_CPU_GENERIC:
2557               break;
2558
2559             default:
2560               strcat (buf, ", fr???");
2561               break;
2562
2563             case EF_FRV_CPU_FR300:
2564               strcat (buf, ", fr300");
2565               break;
2566
2567             case EF_FRV_CPU_FR400:
2568               strcat (buf, ", fr400");
2569               break;
2570             case EF_FRV_CPU_FR405:
2571               strcat (buf, ", fr405");
2572               break;
2573
2574             case EF_FRV_CPU_FR450:
2575               strcat (buf, ", fr450");
2576               break;
2577
2578             case EF_FRV_CPU_FR500:
2579               strcat (buf, ", fr500");
2580               break;
2581             case EF_FRV_CPU_FR550:
2582               strcat (buf, ", fr550");
2583               break;
2584
2585             case EF_FRV_CPU_SIMPLE:
2586               strcat (buf, ", simple");
2587               break;
2588             case EF_FRV_CPU_TOMCAT:
2589               strcat (buf, ", tomcat");
2590               break;
2591             }
2592           break;
2593
2594         case EM_68K:
2595           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2596             strcat (buf, ", m68000");
2597           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2598             strcat (buf, ", cpu32");
2599           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2600             strcat (buf, ", fido_a");
2601           else
2602             {
2603               char const * isa = _("unknown");
2604               char const * mac = _("unknown mac");
2605               char const * additional = NULL;
2606
2607               switch (e_flags & EF_M68K_CF_ISA_MASK)
2608                 {
2609                 case EF_M68K_CF_ISA_A_NODIV:
2610                   isa = "A";
2611                   additional = ", nodiv";
2612                   break;
2613                 case EF_M68K_CF_ISA_A:
2614                   isa = "A";
2615                   break;
2616                 case EF_M68K_CF_ISA_A_PLUS:
2617                   isa = "A+";
2618                   break;
2619                 case EF_M68K_CF_ISA_B_NOUSP:
2620                   isa = "B";
2621                   additional = ", nousp";
2622                   break;
2623                 case EF_M68K_CF_ISA_B:
2624                   isa = "B";
2625                   break;
2626                 case EF_M68K_CF_ISA_C:
2627                   isa = "C";
2628                   break;
2629                 case EF_M68K_CF_ISA_C_NODIV:
2630                   isa = "C";
2631                   additional = ", nodiv";
2632                   break;
2633                 }
2634               strcat (buf, ", cf, isa ");
2635               strcat (buf, isa);
2636               if (additional)
2637                 strcat (buf, additional);
2638               if (e_flags & EF_M68K_CF_FLOAT)
2639                 strcat (buf, ", float");
2640               switch (e_flags & EF_M68K_CF_MAC_MASK)
2641                 {
2642                 case 0:
2643                   mac = NULL;
2644                   break;
2645                 case EF_M68K_CF_MAC:
2646                   mac = "mac";
2647                   break;
2648                 case EF_M68K_CF_EMAC:
2649                   mac = "emac";
2650                   break;
2651                 case EF_M68K_CF_EMAC_B:
2652                   mac = "emac_b";
2653                   break;
2654                 }
2655               if (mac)
2656                 {
2657                   strcat (buf, ", ");
2658                   strcat (buf, mac);
2659                 }
2660             }
2661           break;
2662
2663         case EM_PPC:
2664           if (e_flags & EF_PPC_EMB)
2665             strcat (buf, ", emb");
2666
2667           if (e_flags & EF_PPC_RELOCATABLE)
2668             strcat (buf, _(", relocatable"));
2669
2670           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2671             strcat (buf, _(", relocatable-lib"));
2672           break;
2673
2674         case EM_PPC64:
2675           if (e_flags & EF_PPC64_ABI)
2676             {
2677               char abi[] = ", abiv0";
2678
2679               abi[6] += e_flags & EF_PPC64_ABI;
2680               strcat (buf, abi);
2681             }
2682           break;
2683
2684         case EM_V800:
2685           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2686             strcat (buf, ", RH850 ABI");
2687
2688           if (e_flags & EF_V800_850E3)
2689             strcat (buf, ", V3 architecture");
2690
2691           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2692             strcat (buf, ", FPU not used");
2693
2694           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2695             strcat (buf, ", regmode: COMMON");
2696
2697           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2698             strcat (buf, ", r4 not used");
2699
2700           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2701             strcat (buf, ", r30 not used");
2702
2703           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2704             strcat (buf, ", r5 not used");
2705
2706           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2707             strcat (buf, ", r2 not used");
2708
2709           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2710             {
2711               switch (e_flags & - e_flags)
2712                 {
2713                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2714                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2715                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2716                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2717                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2718                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2719                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2720                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2721                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2722                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2723                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2724                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2725                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2726                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2727                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2728                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2729                 default: break;
2730                 }
2731             }
2732           break;
2733
2734         case EM_V850:
2735         case EM_CYGNUS_V850:
2736           switch (e_flags & EF_V850_ARCH)
2737             {
2738             case E_V850E3V5_ARCH:
2739               strcat (buf, ", v850e3v5");
2740               break;
2741             case E_V850E2V3_ARCH:
2742               strcat (buf, ", v850e2v3");
2743               break;
2744             case E_V850E2_ARCH:
2745               strcat (buf, ", v850e2");
2746               break;
2747             case E_V850E1_ARCH:
2748               strcat (buf, ", v850e1");
2749               break;
2750             case E_V850E_ARCH:
2751               strcat (buf, ", v850e");
2752               break;
2753             case E_V850_ARCH:
2754               strcat (buf, ", v850");
2755               break;
2756             default:
2757               strcat (buf, _(", unknown v850 architecture variant"));
2758               break;
2759             }
2760           break;
2761
2762         case EM_M32R:
2763         case EM_CYGNUS_M32R:
2764           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2765             strcat (buf, ", m32r");
2766           break;
2767
2768         case EM_MIPS:
2769         case EM_MIPS_RS3_LE:
2770           if (e_flags & EF_MIPS_NOREORDER)
2771             strcat (buf, ", noreorder");
2772
2773           if (e_flags & EF_MIPS_PIC)
2774             strcat (buf, ", pic");
2775
2776           if (e_flags & EF_MIPS_CPIC)
2777             strcat (buf, ", cpic");
2778
2779           if (e_flags & EF_MIPS_UCODE)
2780             strcat (buf, ", ugen_reserved");
2781
2782           if (e_flags & EF_MIPS_ABI2)
2783             strcat (buf, ", abi2");
2784
2785           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2786             strcat (buf, ", odk first");
2787
2788           if (e_flags & EF_MIPS_32BITMODE)
2789             strcat (buf, ", 32bitmode");
2790
2791           if (e_flags & EF_MIPS_NAN2008)
2792             strcat (buf, ", nan2008");
2793
2794           if (e_flags & EF_MIPS_FP64)
2795             strcat (buf, ", fp64");
2796
2797           switch ((e_flags & EF_MIPS_MACH))
2798             {
2799             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2800             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2801             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2802             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2803             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2804             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2805             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2806             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2807             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2808             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2809             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2810             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2811             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2812             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2813             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2814             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2815             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2816             case 0:
2817             /* We simply ignore the field in this case to avoid confusion:
2818                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2819                extension.  */
2820               break;
2821             default: strcat (buf, _(", unknown CPU")); break;
2822             }
2823
2824           switch ((e_flags & EF_MIPS_ABI))
2825             {
2826             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2827             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2828             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2829             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2830             case 0:
2831             /* We simply ignore the field in this case to avoid confusion:
2832                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2833                This means it is likely to be an o32 file, but not for
2834                sure.  */
2835               break;
2836             default: strcat (buf, _(", unknown ABI")); break;
2837             }
2838
2839           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2840             strcat (buf, ", mdmx");
2841
2842           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2843             strcat (buf, ", mips16");
2844
2845           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2846             strcat (buf, ", micromips");
2847
2848           switch ((e_flags & EF_MIPS_ARCH))
2849             {
2850             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2851             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2852             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2853             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2854             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2855             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2856             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2857             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
2858             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2859             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2860             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2861             default: strcat (buf, _(", unknown ISA")); break;
2862             }
2863           break;
2864
2865         case EM_NDS32:
2866           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2867           break;
2868
2869         case EM_SH:
2870           switch ((e_flags & EF_SH_MACH_MASK))
2871             {
2872             case EF_SH1: strcat (buf, ", sh1"); break;
2873             case EF_SH2: strcat (buf, ", sh2"); break;
2874             case EF_SH3: strcat (buf, ", sh3"); break;
2875             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2876             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2877             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2878             case EF_SH3E: strcat (buf, ", sh3e"); break;
2879             case EF_SH4: strcat (buf, ", sh4"); break;
2880             case EF_SH5: strcat (buf, ", sh5"); break;
2881             case EF_SH2E: strcat (buf, ", sh2e"); break;
2882             case EF_SH4A: strcat (buf, ", sh4a"); break;
2883             case EF_SH2A: strcat (buf, ", sh2a"); break;
2884             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2885             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2886             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2887             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2888             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2889             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2890             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2891             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2892             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2893             default: strcat (buf, _(", unknown ISA")); break;
2894             }
2895
2896           if (e_flags & EF_SH_PIC)
2897             strcat (buf, ", pic");
2898
2899           if (e_flags & EF_SH_FDPIC)
2900             strcat (buf, ", fdpic");
2901           break;
2902
2903         case EM_OR1K:
2904           if (e_flags & EF_OR1K_NODELAY)
2905             strcat (buf, ", no delay");
2906           break;
2907
2908         case EM_SPARCV9:
2909           if (e_flags & EF_SPARC_32PLUS)
2910             strcat (buf, ", v8+");
2911
2912           if (e_flags & EF_SPARC_SUN_US1)
2913             strcat (buf, ", ultrasparcI");
2914
2915           if (e_flags & EF_SPARC_SUN_US3)
2916             strcat (buf, ", ultrasparcIII");
2917
2918           if (e_flags & EF_SPARC_HAL_R1)
2919             strcat (buf, ", halr1");
2920
2921           if (e_flags & EF_SPARC_LEDATA)
2922             strcat (buf, ", ledata");
2923
2924           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2925             strcat (buf, ", tso");
2926
2927           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2928             strcat (buf, ", pso");
2929
2930           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2931             strcat (buf, ", rmo");
2932           break;
2933
2934         case EM_PARISC:
2935           switch (e_flags & EF_PARISC_ARCH)
2936             {
2937             case EFA_PARISC_1_0:
2938               strcpy (buf, ", PA-RISC 1.0");
2939               break;
2940             case EFA_PARISC_1_1:
2941               strcpy (buf, ", PA-RISC 1.1");
2942               break;
2943             case EFA_PARISC_2_0:
2944               strcpy (buf, ", PA-RISC 2.0");
2945               break;
2946             default:
2947               break;
2948             }
2949           if (e_flags & EF_PARISC_TRAPNIL)
2950             strcat (buf, ", trapnil");
2951           if (e_flags & EF_PARISC_EXT)
2952             strcat (buf, ", ext");
2953           if (e_flags & EF_PARISC_LSB)
2954             strcat (buf, ", lsb");
2955           if (e_flags & EF_PARISC_WIDE)
2956             strcat (buf, ", wide");
2957           if (e_flags & EF_PARISC_NO_KABP)
2958             strcat (buf, ", no kabp");
2959           if (e_flags & EF_PARISC_LAZYSWAP)
2960             strcat (buf, ", lazyswap");
2961           break;
2962
2963         case EM_PJ:
2964         case EM_PJ_OLD:
2965           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2966             strcat (buf, ", new calling convention");
2967
2968           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2969             strcat (buf, ", gnu calling convention");
2970           break;
2971
2972         case EM_IA_64:
2973           if ((e_flags & EF_IA_64_ABI64))
2974             strcat (buf, ", 64-bit");
2975           else
2976             strcat (buf, ", 32-bit");
2977           if ((e_flags & EF_IA_64_REDUCEDFP))
2978             strcat (buf, ", reduced fp model");
2979           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2980             strcat (buf, ", no function descriptors, constant gp");
2981           else if ((e_flags & EF_IA_64_CONS_GP))
2982             strcat (buf, ", constant gp");
2983           if ((e_flags & EF_IA_64_ABSOLUTE))
2984             strcat (buf, ", absolute");
2985           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2986             {
2987               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2988                 strcat (buf, ", vms_linkages");
2989               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2990                 {
2991                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2992                   break;
2993                 case EF_IA_64_VMS_COMCOD_WARNING:
2994                   strcat (buf, ", warning");
2995                   break;
2996                 case EF_IA_64_VMS_COMCOD_ERROR:
2997                   strcat (buf, ", error");
2998                   break;
2999                 case EF_IA_64_VMS_COMCOD_ABORT:
3000                   strcat (buf, ", abort");
3001                   break;
3002                 default:
3003                   abort ();
3004                 }
3005             }
3006           break;
3007
3008         case EM_VAX:
3009           if ((e_flags & EF_VAX_NONPIC))
3010             strcat (buf, ", non-PIC");
3011           if ((e_flags & EF_VAX_DFLOAT))
3012             strcat (buf, ", D-Float");
3013           if ((e_flags & EF_VAX_GFLOAT))
3014             strcat (buf, ", G-Float");
3015           break;
3016
3017         case EM_RL78:
3018           if (e_flags & E_FLAG_RL78_G10)
3019             strcat (buf, ", G10");
3020           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3021             strcat (buf, ", 64-bit doubles");
3022           break;
3023
3024         case EM_RX:
3025           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3026             strcat (buf, ", 64-bit doubles");
3027           if (e_flags & E_FLAG_RX_DSP)
3028             strcat (buf, ", dsp");
3029           if (e_flags & E_FLAG_RX_PID)
3030             strcat (buf, ", pid");
3031           if (e_flags & E_FLAG_RX_ABI)
3032             strcat (buf, ", RX ABI");
3033           break;
3034
3035         case EM_S390:
3036           if (e_flags & EF_S390_HIGH_GPRS)
3037             strcat (buf, ", highgprs");
3038           break;
3039
3040         case EM_TI_C6000:
3041           if ((e_flags & EF_C6000_REL))
3042             strcat (buf, ", relocatable module");
3043           break;
3044
3045         case EM_MSP430:
3046           strcat (buf, _(": architecture variant: "));
3047           switch (e_flags & EF_MSP430_MACH)
3048             {
3049             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3050             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3051             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3052             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3053             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3054             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3055             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3056             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3057             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3058             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3059             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3060             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3061             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3062             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3063             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3064             default:
3065               strcat (buf, _(": unknown")); break;
3066             }
3067
3068           if (e_flags & ~ EF_MSP430_MACH)
3069             strcat (buf, _(": unknown extra flag bits also present"));
3070         }
3071     }
3072
3073   return buf;
3074 }
3075
3076 static const char *
3077 get_osabi_name (unsigned int osabi)
3078 {
3079   static char buff[32];
3080
3081   switch (osabi)
3082     {
3083     case ELFOSABI_NONE:         return "UNIX - System V";
3084     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3085     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3086     case ELFOSABI_GNU:          return "UNIX - GNU";
3087     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3088     case ELFOSABI_AIX:          return "UNIX - AIX";
3089     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3090     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3091     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3092     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3093     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3094     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3095     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3096     case ELFOSABI_AROS:         return "AROS";
3097     case ELFOSABI_FENIXOS:      return "FenixOS";
3098     default:
3099       if (osabi >= 64)
3100         switch (elf_header.e_machine)
3101           {
3102           case EM_ARM:
3103             switch (osabi)
3104               {
3105               case ELFOSABI_ARM:        return "ARM";
3106               default:
3107                 break;
3108               }
3109             break;
3110
3111           case EM_MSP430:
3112           case EM_MSP430_OLD:
3113             switch (osabi)
3114               {
3115               case ELFOSABI_STANDALONE: return _("Standalone App");
3116               default:
3117                 break;
3118               }
3119             break;
3120
3121           case EM_TI_C6000:
3122             switch (osabi)
3123               {
3124               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3125               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3126               default:
3127                 break;
3128               }
3129             break;
3130
3131           default:
3132             break;
3133           }
3134       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3135       return buff;
3136     }
3137 }
3138
3139 static const char *
3140 get_aarch64_segment_type (unsigned long type)
3141 {
3142   switch (type)
3143     {
3144     case PT_AARCH64_ARCHEXT:
3145       return "AARCH64_ARCHEXT";
3146     default:
3147       break;
3148     }
3149
3150   return NULL;
3151 }
3152
3153 static const char *
3154 get_arm_segment_type (unsigned long type)
3155 {
3156   switch (type)
3157     {
3158     case PT_ARM_EXIDX:
3159       return "EXIDX";
3160     default:
3161       break;
3162     }
3163
3164   return NULL;
3165 }
3166
3167 static const char *
3168 get_mips_segment_type (unsigned long type)
3169 {
3170   switch (type)
3171     {
3172     case PT_MIPS_REGINFO:
3173       return "REGINFO";
3174     case PT_MIPS_RTPROC:
3175       return "RTPROC";
3176     case PT_MIPS_OPTIONS:
3177       return "OPTIONS";
3178     case PT_MIPS_ABIFLAGS:
3179       return "ABIFLAGS";
3180     default:
3181       break;
3182     }
3183
3184   return NULL;
3185 }
3186
3187 static const char *
3188 get_parisc_segment_type (unsigned long type)
3189 {
3190   switch (type)
3191     {
3192     case PT_HP_TLS:             return "HP_TLS";
3193     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3194     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3195     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3196     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3197     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3198     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3199     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3200     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3201     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3202     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3203     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3204     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3205     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3206     case PT_HP_STACK:           return "HP_STACK";
3207     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3208     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3209     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3210     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3211     default:
3212       break;
3213     }
3214
3215   return NULL;
3216 }
3217
3218 static const char *
3219 get_ia64_segment_type (unsigned long type)
3220 {
3221   switch (type)
3222     {
3223     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3224     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3225     case PT_HP_TLS:             return "HP_TLS";
3226     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3227     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3228     case PT_IA_64_HP_STACK:     return "HP_STACK";
3229     default:
3230       break;
3231     }
3232
3233   return NULL;
3234 }
3235
3236 static const char *
3237 get_tic6x_segment_type (unsigned long type)
3238 {
3239   switch (type)
3240     {
3241     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3242     default:
3243       break;
3244     }
3245
3246   return NULL;
3247 }
3248
3249 static const char *
3250 get_segment_type (unsigned long p_type)
3251 {
3252   static char buff[32];
3253
3254   switch (p_type)
3255     {
3256     case PT_NULL:       return "NULL";
3257     case PT_LOAD:       return "LOAD";
3258     case PT_DYNAMIC:    return "DYNAMIC";
3259     case PT_INTERP:     return "INTERP";
3260     case PT_NOTE:       return "NOTE";
3261     case PT_SHLIB:      return "SHLIB";
3262     case PT_PHDR:       return "PHDR";
3263     case PT_TLS:        return "TLS";
3264
3265     case PT_GNU_EH_FRAME:
3266                         return "GNU_EH_FRAME";
3267     case PT_GNU_STACK:  return "GNU_STACK";
3268     case PT_GNU_RELRO:  return "GNU_RELRO";
3269
3270     default:
3271       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3272         {
3273           const char * result;
3274
3275           switch (elf_header.e_machine)
3276             {
3277             case EM_AARCH64:
3278               result = get_aarch64_segment_type (p_type);
3279               break;
3280             case EM_ARM:
3281               result = get_arm_segment_type (p_type);
3282               break;
3283             case EM_MIPS:
3284             case EM_MIPS_RS3_LE:
3285               result = get_mips_segment_type (p_type);
3286               break;
3287             case EM_PARISC:
3288               result = get_parisc_segment_type (p_type);
3289               break;
3290             case EM_IA_64:
3291               result = get_ia64_segment_type (p_type);
3292               break;
3293             case EM_TI_C6000:
3294               result = get_tic6x_segment_type (p_type);
3295               break;
3296             default:
3297               result = NULL;
3298               break;
3299             }
3300
3301           if (result != NULL)
3302             return result;
3303
3304           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3305         }
3306       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3307         {
3308           const char * result;
3309
3310           switch (elf_header.e_machine)
3311             {
3312             case EM_PARISC:
3313               result = get_parisc_segment_type (p_type);
3314               break;
3315             case EM_IA_64:
3316               result = get_ia64_segment_type (p_type);
3317               break;
3318             default:
3319               result = NULL;
3320               break;
3321             }
3322
3323           if (result != NULL)
3324             return result;
3325
3326           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3327         }
3328       else
3329         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3330
3331       return buff;
3332     }
3333 }
3334
3335 static const char *
3336 get_mips_section_type_name (unsigned int sh_type)
3337 {
3338   switch (sh_type)
3339     {
3340     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3341     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3342     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3343     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3344     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3345     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3346     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3347     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3348     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3349     case SHT_MIPS_RELD:          return "MIPS_RELD";
3350     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3351     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3352     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3353     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3354     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3355     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3356     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3357     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3358     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3359     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3360     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3361     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3362     case SHT_MIPS_LINE:          return "MIPS_LINE";
3363     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3364     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3365     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3366     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3367     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3368     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3369     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3370     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3371     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3372     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3373     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3374     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3375     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3376     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3377     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3378     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3379     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3380     default:
3381       break;
3382     }
3383   return NULL;
3384 }
3385
3386 static const char *
3387 get_parisc_section_type_name (unsigned int sh_type)
3388 {
3389   switch (sh_type)
3390     {
3391     case SHT_PARISC_EXT:        return "PARISC_EXT";
3392     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3393     case SHT_PARISC_DOC:        return "PARISC_DOC";
3394     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3395     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3396     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3397     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3398     default:
3399       break;
3400     }
3401   return NULL;
3402 }
3403
3404 static const char *
3405 get_ia64_section_type_name (unsigned int sh_type)
3406 {
3407   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3408   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3409     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3410
3411   switch (sh_type)
3412     {
3413     case SHT_IA_64_EXT:                return "IA_64_EXT";
3414     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3415     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3416     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3417     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3418     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3419     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3420     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3421     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3422     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3423     default:
3424       break;
3425     }
3426   return NULL;
3427 }
3428
3429 static const char *
3430 get_x86_64_section_type_name (unsigned int sh_type)
3431 {
3432   switch (sh_type)
3433     {
3434     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3435     default:
3436       break;
3437     }
3438   return NULL;
3439 }
3440
3441 static const char *
3442 get_aarch64_section_type_name (unsigned int sh_type)
3443 {
3444   switch (sh_type)
3445     {
3446     case SHT_AARCH64_ATTRIBUTES:
3447       return "AARCH64_ATTRIBUTES";
3448     default:
3449       break;
3450     }
3451   return NULL;
3452 }
3453
3454 static const char *
3455 get_arm_section_type_name (unsigned int sh_type)
3456 {
3457   switch (sh_type)
3458     {
3459     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3460     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3461     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3462     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3463     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3464     default:
3465       break;
3466     }
3467   return NULL;
3468 }
3469
3470 static const char *
3471 get_tic6x_section_type_name (unsigned int sh_type)
3472 {
3473   switch (sh_type)
3474     {
3475     case SHT_C6000_UNWIND:
3476       return "C6000_UNWIND";
3477     case SHT_C6000_PREEMPTMAP:
3478       return "C6000_PREEMPTMAP";
3479     case SHT_C6000_ATTRIBUTES:
3480       return "C6000_ATTRIBUTES";
3481     case SHT_TI_ICODE:
3482       return "TI_ICODE";
3483     case SHT_TI_XREF:
3484       return "TI_XREF";
3485     case SHT_TI_HANDLER:
3486       return "TI_HANDLER";
3487     case SHT_TI_INITINFO:
3488       return "TI_INITINFO";
3489     case SHT_TI_PHATTRS:
3490       return "TI_PHATTRS";
3491     default:
3492       break;
3493     }
3494   return NULL;
3495 }
3496
3497 static const char *
3498 get_msp430x_section_type_name (unsigned int sh_type)
3499 {
3500   switch (sh_type)
3501     {
3502     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3503     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3504     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3505     default: return NULL;
3506     }
3507 }
3508
3509 static const char *
3510 get_section_type_name (unsigned int sh_type)
3511 {
3512   static char buff[32];
3513
3514   switch (sh_type)
3515     {
3516     case SHT_NULL:              return "NULL";
3517     case SHT_PROGBITS:          return "PROGBITS";
3518     case SHT_SYMTAB:            return "SYMTAB";
3519     case SHT_STRTAB:            return "STRTAB";
3520     case SHT_RELA:              return "RELA";
3521     case SHT_HASH:              return "HASH";
3522     case SHT_DYNAMIC:           return "DYNAMIC";
3523     case SHT_NOTE:              return "NOTE";
3524     case SHT_NOBITS:            return "NOBITS";
3525     case SHT_REL:               return "REL";
3526     case SHT_SHLIB:             return "SHLIB";
3527     case SHT_DYNSYM:            return "DYNSYM";
3528     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3529     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3530     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3531     case SHT_GNU_HASH:          return "GNU_HASH";
3532     case SHT_GROUP:             return "GROUP";
3533     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3534     case SHT_GNU_verdef:        return "VERDEF";
3535     case SHT_GNU_verneed:       return "VERNEED";
3536     case SHT_GNU_versym:        return "VERSYM";
3537     case 0x6ffffff0:            return "VERSYM";
3538     case 0x6ffffffc:            return "VERDEF";
3539     case 0x7ffffffd:            return "AUXILIARY";
3540     case 0x7fffffff:            return "FILTER";
3541     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3542
3543     default:
3544       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3545         {
3546           const char * result;
3547
3548           switch (elf_header.e_machine)
3549             {
3550             case EM_MIPS:
3551             case EM_MIPS_RS3_LE:
3552               result = get_mips_section_type_name (sh_type);
3553               break;
3554             case EM_PARISC:
3555               result = get_parisc_section_type_name (sh_type);
3556               break;
3557             case EM_IA_64:
3558               result = get_ia64_section_type_name (sh_type);
3559               break;
3560             case EM_X86_64:
3561             case EM_L1OM:
3562             case EM_K1OM:
3563               result = get_x86_64_section_type_name (sh_type);
3564               break;
3565             case EM_AARCH64:
3566               result = get_aarch64_section_type_name (sh_type);
3567               break;
3568             case EM_ARM:
3569               result = get_arm_section_type_name (sh_type);
3570               break;
3571             case EM_TI_C6000:
3572               result = get_tic6x_section_type_name (sh_type);
3573               break;
3574             case EM_MSP430:
3575               result = get_msp430x_section_type_name (sh_type);
3576               break;
3577             default:
3578               result = NULL;
3579               break;
3580             }
3581
3582           if (result != NULL)
3583             return result;
3584
3585           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3586         }
3587       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3588         {
3589           const char * result;
3590
3591           switch (elf_header.e_machine)
3592             {
3593             case EM_IA_64:
3594               result = get_ia64_section_type_name (sh_type);
3595               break;
3596             default:
3597               result = NULL;
3598               break;
3599             }
3600
3601           if (result != NULL)
3602             return result;
3603
3604           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3605         }
3606       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3607         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3608       else
3609         /* This message is probably going to be displayed in a 15
3610            character wide field, so put the hex value first.  */
3611         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3612
3613       return buff;
3614     }
3615 }
3616
3617 #define OPTION_DEBUG_DUMP       512
3618 #define OPTION_DYN_SYMS         513
3619 #define OPTION_DWARF_DEPTH      514
3620 #define OPTION_DWARF_START      515
3621 #define OPTION_DWARF_CHECK      516
3622
3623 static struct option options[] =
3624 {
3625   {"all",              no_argument, 0, 'a'},
3626   {"file-header",      no_argument, 0, 'h'},
3627   {"program-headers",  no_argument, 0, 'l'},
3628   {"headers",          no_argument, 0, 'e'},
3629   {"histogram",        no_argument, 0, 'I'},
3630   {"segments",         no_argument, 0, 'l'},
3631   {"sections",         no_argument, 0, 'S'},
3632   {"section-headers",  no_argument, 0, 'S'},
3633   {"section-groups",   no_argument, 0, 'g'},
3634   {"section-details",  no_argument, 0, 't'},
3635   {"full-section-name",no_argument, 0, 'N'},
3636   {"symbols",          no_argument, 0, 's'},
3637   {"syms",             no_argument, 0, 's'},
3638   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3639   {"relocs",           no_argument, 0, 'r'},
3640   {"notes",            no_argument, 0, 'n'},
3641   {"dynamic",          no_argument, 0, 'd'},
3642   {"arch-specific",    no_argument, 0, 'A'},
3643   {"version-info",     no_argument, 0, 'V'},
3644   {"use-dynamic",      no_argument, 0, 'D'},
3645   {"unwind",           no_argument, 0, 'u'},
3646   {"archive-index",    no_argument, 0, 'c'},
3647   {"hex-dump",         required_argument, 0, 'x'},
3648   {"relocated-dump",   required_argument, 0, 'R'},
3649   {"string-dump",      required_argument, 0, 'p'},
3650 #ifdef SUPPORT_DISASSEMBLY
3651   {"instruction-dump", required_argument, 0, 'i'},
3652 #endif
3653   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3654
3655   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3656   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3657   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3658
3659   {"version",          no_argument, 0, 'v'},
3660   {"wide",             no_argument, 0, 'W'},
3661   {"help",             no_argument, 0, 'H'},
3662   {0,                  no_argument, 0, 0}
3663 };
3664
3665 static void
3666 usage (FILE * stream)
3667 {
3668   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3669   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3670   fprintf (stream, _(" Options are:\n\
3671   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3672   -h --file-header       Display the ELF file header\n\
3673   -l --program-headers   Display the program headers\n\
3674      --segments          An alias for --program-headers\n\
3675   -S --section-headers   Display the sections' header\n\
3676      --sections          An alias for --section-headers\n\
3677   -g --section-groups    Display the section groups\n\
3678   -t --section-details   Display the section details\n\
3679   -e --headers           Equivalent to: -h -l -S\n\
3680   -s --syms              Display the symbol table\n\
3681      --symbols           An alias for --syms\n\
3682   --dyn-syms             Display the dynamic symbol table\n\
3683   -n --notes             Display the core notes (if present)\n\
3684   -r --relocs            Display the relocations (if present)\n\
3685   -u --unwind            Display the unwind info (if present)\n\
3686   -d --dynamic           Display the dynamic section (if present)\n\
3687   -V --version-info      Display the version sections (if present)\n\
3688   -A --arch-specific     Display architecture specific information (if any)\n\
3689   -c --archive-index     Display the symbol/file index in an archive\n\
3690   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3691   -x --hex-dump=<number|name>\n\
3692                          Dump the contents of section <number|name> as bytes\n\
3693   -p --string-dump=<number|name>\n\
3694                          Dump the contents of section <number|name> as strings\n\
3695   -R --relocated-dump=<number|name>\n\
3696                          Dump the contents of section <number|name> as relocated bytes\n\
3697   -w[lLiaprmfFsoRt] or\n\
3698   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3699                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3700                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3701                =addr,=cu_index]\n\
3702                          Display the contents of DWARF2 debug sections\n"));
3703   fprintf (stream, _("\
3704   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3705   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3706                          or deeper\n"));
3707 #ifdef SUPPORT_DISASSEMBLY
3708   fprintf (stream, _("\
3709   -i --instruction-dump=<number|name>\n\
3710                          Disassemble the contents of section <number|name>\n"));
3711 #endif
3712   fprintf (stream, _("\
3713   -I --histogram         Display histogram of bucket list lengths\n\
3714   -W --wide              Allow output width to exceed 80 characters\n\
3715   @<file>                Read options from <file>\n\
3716   -H --help              Display this information\n\
3717   -v --version           Display the version number of readelf\n"));
3718
3719   if (REPORT_BUGS_TO[0] && stream == stdout)
3720     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3721
3722   exit (stream == stdout ? 0 : 1);
3723 }
3724
3725 /* Record the fact that the user wants the contents of section number
3726    SECTION to be displayed using the method(s) encoded as flags bits
3727    in TYPE.  Note, TYPE can be zero if we are creating the array for
3728    the first time.  */
3729
3730 static void
3731 request_dump_bynumber (unsigned int section, dump_type type)
3732 {
3733   if (section >= num_dump_sects)
3734     {
3735       dump_type * new_dump_sects;
3736
3737       new_dump_sects = (dump_type *) calloc (section + 1,
3738                                              sizeof (* dump_sects));
3739
3740       if (new_dump_sects == NULL)
3741         error (_("Out of memory allocating dump request table.\n"));
3742       else
3743         {
3744           /* Copy current flag settings.  */
3745           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3746
3747           free (dump_sects);
3748
3749           dump_sects = new_dump_sects;
3750           num_dump_sects = section + 1;
3751         }
3752     }
3753
3754   if (dump_sects)
3755     dump_sects[section] |= type;
3756
3757   return;
3758 }
3759
3760 /* Request a dump by section name.  */
3761
3762 static void
3763 request_dump_byname (const char * section, dump_type type)
3764 {
3765   struct dump_list_entry * new_request;
3766
3767   new_request = (struct dump_list_entry *)
3768       malloc (sizeof (struct dump_list_entry));
3769   if (!new_request)
3770     error (_("Out of memory allocating dump request table.\n"));
3771
3772   new_request->name = strdup (section);
3773   if (!new_request->name)
3774     error (_("Out of memory allocating dump request table.\n"));
3775
3776   new_request->type = type;
3777
3778   new_request->next = dump_sects_byname;
3779   dump_sects_byname = new_request;
3780 }
3781
3782 static inline void
3783 request_dump (dump_type type)
3784 {
3785   int section;
3786   char * cp;
3787
3788   do_dump++;
3789   section = strtoul (optarg, & cp, 0);
3790
3791   if (! *cp && section >= 0)
3792     request_dump_bynumber (section, type);
3793   else
3794     request_dump_byname (optarg, type);
3795 }
3796
3797
3798 static void
3799 parse_args (int argc, char ** argv)
3800 {
3801   int c;
3802
3803   if (argc < 2)
3804     usage (stderr);
3805
3806   while ((c = getopt_long
3807           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3808     {
3809       switch (c)
3810         {
3811         case 0:
3812           /* Long options.  */
3813           break;
3814         case 'H':
3815           usage (stdout);
3816           break;
3817
3818         case 'a':
3819           do_syms++;
3820           do_reloc++;
3821           do_unwind++;
3822           do_dynamic++;
3823           do_header++;
3824           do_sections++;
3825           do_section_groups++;
3826           do_segments++;
3827           do_version++;
3828           do_histogram++;
3829           do_arch++;
3830           do_notes++;
3831           break;
3832         case 'g':
3833           do_section_groups++;
3834           break;
3835         case 't':
3836         case 'N':
3837           do_sections++;
3838           do_section_details++;
3839           break;
3840         case 'e':
3841           do_header++;
3842           do_sections++;
3843           do_segments++;
3844           break;
3845         case 'A':
3846           do_arch++;
3847           break;
3848         case 'D':
3849           do_using_dynamic++;
3850           break;
3851         case 'r':
3852           do_reloc++;
3853           break;
3854         case 'u':
3855           do_unwind++;
3856           break;
3857         case 'h':
3858           do_header++;
3859           break;
3860         case 'l':
3861           do_segments++;
3862           break;
3863         case 's':
3864           do_syms++;
3865           break;
3866         case 'S':
3867           do_sections++;
3868           break;
3869         case 'd':
3870           do_dynamic++;
3871           break;
3872         case 'I':
3873           do_histogram++;
3874           break;
3875         case 'n':
3876           do_notes++;
3877           break;
3878         case 'c':
3879           do_archive_index++;
3880           break;
3881         case 'x':
3882           request_dump (HEX_DUMP);
3883           break;
3884         case 'p':
3885           request_dump (STRING_DUMP);
3886           break;
3887         case 'R':
3888           request_dump (RELOC_DUMP);
3889           break;
3890         case 'w':
3891           do_dump++;
3892           if (optarg == 0)
3893             {
3894               do_debugging = 1;
3895               dwarf_select_sections_all ();
3896             }
3897           else
3898             {
3899               do_debugging = 0;
3900               dwarf_select_sections_by_letters (optarg);
3901             }
3902           break;
3903         case OPTION_DEBUG_DUMP:
3904           do_dump++;
3905           if (optarg == 0)
3906             do_debugging = 1;
3907           else
3908             {
3909               do_debugging = 0;
3910               dwarf_select_sections_by_names (optarg);
3911             }
3912           break;
3913         case OPTION_DWARF_DEPTH:
3914           {
3915             char *cp;
3916
3917             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3918           }
3919           break;
3920         case OPTION_DWARF_START:
3921           {
3922             char *cp;
3923
3924             dwarf_start_die = strtoul (optarg, & cp, 0);
3925           }
3926           break;
3927         case OPTION_DWARF_CHECK:
3928           dwarf_check = 1;
3929           break;
3930         case OPTION_DYN_SYMS:
3931           do_dyn_syms++;
3932           break;
3933 #ifdef SUPPORT_DISASSEMBLY
3934         case 'i':
3935           request_dump (DISASS_DUMP);
3936           break;
3937 #endif
3938         case 'v':
3939           print_version (program_name);
3940           break;
3941         case 'V':
3942           do_version++;
3943           break;
3944         case 'W':
3945           do_wide++;
3946           break;
3947         default:
3948           /* xgettext:c-format */
3949           error (_("Invalid option '-%c'\n"), c);
3950           /* Drop through.  */
3951         case '?':
3952           usage (stderr);
3953         }
3954     }
3955
3956   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3957       && !do_segments && !do_header && !do_dump && !do_version
3958       && !do_histogram && !do_debugging && !do_arch && !do_notes
3959       && !do_section_groups && !do_archive_index
3960       && !do_dyn_syms)
3961     usage (stderr);
3962   else if (argc < 3)
3963     {
3964       warn (_("Nothing to do.\n"));
3965       usage (stderr);
3966     }
3967 }
3968
3969 static const char *
3970 get_elf_class (unsigned int elf_class)
3971 {
3972   static char buff[32];
3973
3974   switch (elf_class)
3975     {
3976     case ELFCLASSNONE: return _("none");
3977     case ELFCLASS32:   return "ELF32";
3978     case ELFCLASS64:   return "ELF64";
3979     default:
3980       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3981       return buff;
3982     }
3983 }
3984
3985 static const char *
3986 get_data_encoding (unsigned int encoding)
3987 {
3988   static char buff[32];
3989
3990   switch (encoding)
3991     {
3992     case ELFDATANONE: return _("none");
3993     case ELFDATA2LSB: return _("2's complement, little endian");
3994     case ELFDATA2MSB: return _("2's complement, big endian");
3995     default:
3996       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3997       return buff;
3998     }
3999 }
4000
4001 /* Decode the data held in 'elf_header'.  */
4002
4003 static int
4004 process_file_header (void)
4005 {
4006   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4007       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4008       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4009       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4010     {
4011       error
4012         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4013       return 0;
4014     }
4015
4016   init_dwarf_regnames (elf_header.e_machine);
4017
4018   if (do_header)
4019     {
4020       int i;
4021
4022       printf (_("ELF Header:\n"));
4023       printf (_("  Magic:   "));
4024       for (i = 0; i < EI_NIDENT; i++)
4025         printf ("%2.2x ", elf_header.e_ident[i]);
4026       printf ("\n");
4027       printf (_("  Class:                             %s\n"),
4028               get_elf_class (elf_header.e_ident[EI_CLASS]));
4029       printf (_("  Data:                              %s\n"),
4030               get_data_encoding (elf_header.e_ident[EI_DATA]));
4031       printf (_("  Version:                           %d %s\n"),
4032               elf_header.e_ident[EI_VERSION],
4033               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4034                ? "(current)"
4035                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4036                   ? _("<unknown: %lx>")
4037                   : "")));
4038       printf (_("  OS/ABI:                            %s\n"),
4039               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4040       printf (_("  ABI Version:                       %d\n"),
4041               elf_header.e_ident[EI_ABIVERSION]);
4042       printf (_("  Type:                              %s\n"),
4043               get_file_type (elf_header.e_type));
4044       printf (_("  Machine:                           %s\n"),
4045               get_machine_name (elf_header.e_machine));
4046       printf (_("  Version:                           0x%lx\n"),
4047               (unsigned long) elf_header.e_version);
4048
4049       printf (_("  Entry point address:               "));
4050       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4051       printf (_("\n  Start of program headers:          "));
4052       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4053       printf (_(" (bytes into file)\n  Start of section headers:          "));
4054       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4055       printf (_(" (bytes into file)\n"));
4056
4057       printf (_("  Flags:                             0x%lx%s\n"),
4058               (unsigned long) elf_header.e_flags,
4059               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4060       printf (_("  Size of this header:               %ld (bytes)\n"),
4061               (long) elf_header.e_ehsize);
4062       printf (_("  Size of program headers:           %ld (bytes)\n"),
4063               (long) elf_header.e_phentsize);
4064       printf (_("  Number of program headers:         %ld"),
4065               (long) elf_header.e_phnum);
4066       if (section_headers != NULL
4067           && elf_header.e_phnum == PN_XNUM
4068           && section_headers[0].sh_info != 0)
4069         printf (" (%ld)", (long) section_headers[0].sh_info);
4070       putc ('\n', stdout);
4071       printf (_("  Size of section headers:           %ld (bytes)\n"),
4072               (long) elf_header.e_shentsize);
4073       printf (_("  Number of section headers:         %ld"),
4074               (long) elf_header.e_shnum);
4075       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4076         printf (" (%ld)", (long) section_headers[0].sh_size);
4077       putc ('\n', stdout);
4078       printf (_("  Section header string table index: %ld"),
4079               (long) elf_header.e_shstrndx);
4080       if (section_headers != NULL
4081           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4082         printf (" (%u)", section_headers[0].sh_link);
4083       else if (elf_header.e_shstrndx != SHN_UNDEF
4084                && elf_header.e_shstrndx >= elf_header.e_shnum)
4085         printf (_(" <corrupt: out of range>"));
4086       putc ('\n', stdout);
4087     }
4088
4089   if (section_headers != NULL)
4090     {
4091       if (elf_header.e_phnum == PN_XNUM
4092           && section_headers[0].sh_info != 0)
4093         elf_header.e_phnum = section_headers[0].sh_info;
4094       if (elf_header.e_shnum == SHN_UNDEF)
4095         elf_header.e_shnum = section_headers[0].sh_size;
4096       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4097         elf_header.e_shstrndx = section_headers[0].sh_link;
4098       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4099         elf_header.e_shstrndx = SHN_UNDEF;
4100       free (section_headers);
4101       section_headers = NULL;
4102     }
4103
4104   return 1;
4105 }
4106
4107 static bfd_boolean
4108 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4109 {
4110   Elf32_External_Phdr * phdrs;
4111   Elf32_External_Phdr * external;
4112   Elf_Internal_Phdr *   internal;
4113   unsigned int i;
4114   unsigned int size = elf_header.e_phentsize;
4115   unsigned int num  = elf_header.e_phnum;
4116
4117   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4118   if (size == 0 || num == 0)
4119     return FALSE;
4120   if (size < sizeof * phdrs)
4121     {
4122       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4123       return FALSE;
4124     }
4125   if (size > sizeof * phdrs)
4126     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4127
4128   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4129                                             size, num, _("program headers"));
4130   if (phdrs == NULL)
4131     return FALSE;
4132
4133   for (i = 0, internal = pheaders, external = phdrs;
4134        i < elf_header.e_phnum;
4135        i++, internal++, external++)
4136     {
4137       internal->p_type   = BYTE_GET (external->p_type);
4138       internal->p_offset = BYTE_GET (external->p_offset);
4139       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4140       internal->p_paddr  = BYTE_GET (external->p_paddr);
4141       internal->p_filesz = BYTE_GET (external->p_filesz);
4142       internal->p_memsz  = BYTE_GET (external->p_memsz);
4143       internal->p_flags  = BYTE_GET (external->p_flags);
4144       internal->p_align  = BYTE_GET (external->p_align);
4145     }
4146
4147   free (phdrs);
4148   return TRUE;
4149 }
4150
4151 static bfd_boolean
4152 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4153 {
4154   Elf64_External_Phdr * phdrs;
4155   Elf64_External_Phdr * external;
4156   Elf_Internal_Phdr *   internal;
4157   unsigned int i;
4158   unsigned int size = elf_header.e_phentsize;
4159   unsigned int num  = elf_header.e_phnum;
4160
4161   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4162   if (size == 0 || num == 0)
4163     return FALSE;
4164   if (size < sizeof * phdrs)
4165     {
4166       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4167       return FALSE;
4168     }
4169   if (size > sizeof * phdrs)
4170     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4171
4172   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4173                                             size, num, _("program headers"));
4174   if (!phdrs)
4175     return FALSE;
4176
4177   for (i = 0, internal = pheaders, external = phdrs;
4178        i < elf_header.e_phnum;
4179        i++, internal++, external++)
4180     {
4181       internal->p_type   = BYTE_GET (external->p_type);
4182       internal->p_flags  = BYTE_GET (external->p_flags);
4183       internal->p_offset = BYTE_GET (external->p_offset);
4184       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4185       internal->p_paddr  = BYTE_GET (external->p_paddr);
4186       internal->p_filesz = BYTE_GET (external->p_filesz);
4187       internal->p_memsz  = BYTE_GET (external->p_memsz);
4188       internal->p_align  = BYTE_GET (external->p_align);
4189     }
4190
4191   free (phdrs);
4192   return TRUE;
4193 }
4194
4195 /* Returns 1 if the program headers were read into `program_headers'.  */
4196
4197 static int
4198 get_program_headers (FILE * file)
4199 {
4200   Elf_Internal_Phdr * phdrs;
4201
4202   /* Check cache of prior read.  */
4203   if (program_headers != NULL)
4204     return 1;
4205
4206   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4207                                          sizeof (Elf_Internal_Phdr));
4208
4209   if (phdrs == NULL)
4210     {
4211       error (_("Out of memory\n"));
4212       return 0;
4213     }
4214
4215   if (is_32bit_elf
4216       ? get_32bit_program_headers (file, phdrs)
4217       : get_64bit_program_headers (file, phdrs))
4218     {
4219       program_headers = phdrs;
4220       return 1;
4221     }
4222
4223   free (phdrs);
4224   return 0;
4225 }
4226
4227 /* Returns 1 if the program headers were loaded.  */
4228
4229 static int
4230 process_program_headers (FILE * file)
4231 {
4232   Elf_Internal_Phdr * segment;
4233   unsigned int i;
4234
4235   if (elf_header.e_phnum == 0)
4236     {
4237       /* PR binutils/12467.  */
4238       if (elf_header.e_phoff != 0)
4239         warn (_("possibly corrupt ELF header - it has a non-zero program"
4240                 " header offset, but no program headers"));
4241       else if (do_segments)
4242         printf (_("\nThere are no program headers in this file.\n"));
4243       return 0;
4244     }
4245
4246   if (do_segments && !do_header)
4247     {
4248       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4249       printf (_("Entry point "));
4250       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4251       printf (_("\nThere are %d program headers, starting at offset "),
4252               elf_header.e_phnum);
4253       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4254       printf ("\n");
4255     }
4256
4257   if (! get_program_headers (file))
4258       return 0;
4259
4260   if (do_segments)
4261     {
4262       if (elf_header.e_phnum > 1)
4263         printf (_("\nProgram Headers:\n"));
4264       else
4265         printf (_("\nProgram Headers:\n"));
4266
4267       if (is_32bit_elf)
4268         printf
4269           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4270       else if (do_wide)
4271         printf
4272           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4273       else
4274         {
4275           printf
4276             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4277           printf
4278             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4279         }
4280     }
4281
4282   dynamic_addr = 0;
4283   dynamic_size = 0;
4284
4285   for (i = 0, segment = program_headers;
4286        i < elf_header.e_phnum;
4287        i++, segment++)
4288     {
4289       if (do_segments)
4290         {
4291           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4292
4293           if (is_32bit_elf)
4294             {
4295               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4296               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4297               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4298               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4299               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4300               printf ("%c%c%c ",
4301                       (segment->p_flags & PF_R ? 'R' : ' '),
4302                       (segment->p_flags & PF_W ? 'W' : ' '),
4303                       (segment->p_flags & PF_X ? 'E' : ' '));
4304               printf ("%#lx", (unsigned long) segment->p_align);
4305             }
4306           else if (do_wide)
4307             {
4308               if ((unsigned long) segment->p_offset == segment->p_offset)
4309                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4310               else
4311                 {
4312                   print_vma (segment->p_offset, FULL_HEX);
4313                   putchar (' ');
4314                 }
4315
4316               print_vma (segment->p_vaddr, FULL_HEX);
4317               putchar (' ');
4318               print_vma (segment->p_paddr, FULL_HEX);
4319               putchar (' ');
4320
4321               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4322                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4323               else
4324                 {
4325                   print_vma (segment->p_filesz, FULL_HEX);
4326                   putchar (' ');
4327                 }
4328
4329               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4330                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4331               else
4332                 {
4333                   print_vma (segment->p_memsz, FULL_HEX);
4334                 }
4335
4336               printf (" %c%c%c ",
4337                       (segment->p_flags & PF_R ? 'R' : ' '),
4338                       (segment->p_flags & PF_W ? 'W' : ' '),
4339                       (segment->p_flags & PF_X ? 'E' : ' '));
4340
4341               if ((unsigned long) segment->p_align == segment->p_align)
4342                 printf ("%#lx", (unsigned long) segment->p_align);
4343               else
4344                 {
4345                   print_vma (segment->p_align, PREFIX_HEX);
4346                 }
4347             }
4348           else
4349             {
4350               print_vma (segment->p_offset, FULL_HEX);
4351               putchar (' ');
4352               print_vma (segment->p_vaddr, FULL_HEX);
4353               putchar (' ');
4354               print_vma (segment->p_paddr, FULL_HEX);
4355               printf ("\n                 ");
4356               print_vma (segment->p_filesz, FULL_HEX);
4357               putchar (' ');
4358               print_vma (segment->p_memsz, FULL_HEX);
4359               printf ("  %c%c%c    ",
4360                       (segment->p_flags & PF_R ? 'R' : ' '),
4361                       (segment->p_flags & PF_W ? 'W' : ' '),
4362                       (segment->p_flags & PF_X ? 'E' : ' '));
4363               print_vma (segment->p_align, HEX);
4364             }
4365         }
4366
4367       if (do_segments)
4368         putc ('\n', stdout);
4369
4370       switch (segment->p_type)
4371         {
4372         case PT_DYNAMIC:
4373           if (dynamic_addr)
4374             error (_("more than one dynamic segment\n"));
4375
4376           /* By default, assume that the .dynamic section is the first
4377              section in the DYNAMIC segment.  */
4378           dynamic_addr = segment->p_offset;
4379           dynamic_size = segment->p_filesz;
4380           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4381           if (dynamic_addr + dynamic_size >= current_file_size)
4382             {
4383               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4384               dynamic_addr = dynamic_size = 0;
4385             }
4386
4387           /* Try to locate the .dynamic section. If there is
4388              a section header table, we can easily locate it.  */
4389           if (section_headers != NULL)
4390             {
4391               Elf_Internal_Shdr * sec;
4392
4393               sec = find_section (".dynamic");
4394               if (sec == NULL || sec->sh_size == 0)
4395                 {
4396                   /* A corresponding .dynamic section is expected, but on
4397                      IA-64/OpenVMS it is OK for it to be missing.  */
4398                   if (!is_ia64_vms ())
4399                     error (_("no .dynamic section in the dynamic segment\n"));
4400                   break;
4401                 }
4402
4403               if (sec->sh_type == SHT_NOBITS)
4404                 {
4405                   dynamic_size = 0;
4406                   break;
4407                 }
4408
4409               dynamic_addr = sec->sh_offset;
4410               dynamic_size = sec->sh_size;
4411
4412               if (dynamic_addr < segment->p_offset
4413                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4414                 warn (_("the .dynamic section is not contained"
4415                         " within the dynamic segment\n"));
4416               else if (dynamic_addr > segment->p_offset)
4417                 warn (_("the .dynamic section is not the first section"
4418                         " in the dynamic segment.\n"));
4419             }
4420           break;
4421
4422         case PT_INTERP:
4423           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4424                      SEEK_SET))
4425             error (_("Unable to find program interpreter name\n"));
4426           else
4427             {
4428               char fmt [32];
4429               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4430
4431               if (ret >= (int) sizeof (fmt) || ret < 0)
4432                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4433
4434               program_interpreter[0] = 0;
4435               if (fscanf (file, fmt, program_interpreter) <= 0)
4436                 error (_("Unable to read program interpreter name\n"));
4437
4438               if (do_segments)
4439                 printf (_("      [Requesting program interpreter: %s]\n"),
4440                     program_interpreter);
4441             }
4442           break;
4443         }
4444     }
4445
4446   if (do_segments && section_headers != NULL && string_table != NULL)
4447     {
4448       printf (_("\n Section to Segment mapping:\n"));
4449       printf (_("  Segment Sections...\n"));
4450
4451       for (i = 0; i < elf_header.e_phnum; i++)
4452         {
4453           unsigned int j;
4454           Elf_Internal_Shdr * section;
4455
4456           segment = program_headers + i;
4457           section = section_headers + 1;
4458
4459           printf ("   %2.2d     ", i);
4460
4461           for (j = 1; j < elf_header.e_shnum; j++, section++)
4462             {
4463               if (!ELF_TBSS_SPECIAL (section, segment)
4464                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4465                 printf ("%s ", SECTION_NAME (section));
4466             }
4467
4468           putc ('\n',stdout);
4469         }
4470     }
4471
4472   return 1;
4473 }
4474
4475
4476 /* Find the file offset corresponding to VMA by using the program headers.  */
4477
4478 static long
4479 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4480 {
4481   Elf_Internal_Phdr * seg;
4482
4483   if (! get_program_headers (file))
4484     {
4485       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4486       return (long) vma;
4487     }
4488
4489   for (seg = program_headers;
4490        seg < program_headers + elf_header.e_phnum;
4491        ++seg)
4492     {
4493       if (seg->p_type != PT_LOAD)
4494         continue;
4495
4496       if (vma >= (seg->p_vaddr & -seg->p_align)
4497           && vma + size <= seg->p_vaddr + seg->p_filesz)
4498         return vma - seg->p_vaddr + seg->p_offset;
4499     }
4500
4501   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4502         (unsigned long) vma);
4503   return (long) vma;
4504 }
4505
4506
4507 /* Allocate memory and load the sections headers into the global pointer
4508    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4509    generate any error messages if the load fails.  */
4510
4511 static bfd_boolean
4512 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4513 {
4514   Elf32_External_Shdr * shdrs;
4515   Elf_Internal_Shdr *   internal;
4516   unsigned int i;
4517   unsigned int size = elf_header.e_shentsize;
4518   unsigned int num = probe ? 1 : elf_header.e_shnum;
4519
4520   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4521   if (size == 0 || num == 0)
4522     return FALSE;
4523   if (size < sizeof * shdrs)
4524     {
4525       if (! probe)
4526         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4527       return FALSE;
4528     }
4529   if (!probe && size > sizeof * shdrs)
4530     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4531
4532   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4533                                             size, num,
4534                                             probe ? NULL : _("section headers"));
4535   if (shdrs == NULL)
4536     return FALSE;
4537
4538   if (section_headers != NULL)
4539     free (section_headers);
4540   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4541                                                    sizeof (Elf_Internal_Shdr));
4542   if (section_headers == NULL)
4543     {
4544       if (!probe)
4545         error (_("Out of memory\n"));
4546       return FALSE;
4547     }
4548
4549   for (i = 0, internal = section_headers;
4550        i < num;
4551        i++, internal++)
4552     {
4553       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4554       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4555       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4556       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4557       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4558       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4559       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4560       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4561       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4562       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4563     }
4564
4565   free (shdrs);
4566   return TRUE;
4567 }
4568
4569 static bfd_boolean
4570 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4571 {
4572   Elf64_External_Shdr * shdrs;
4573   Elf_Internal_Shdr *   internal;
4574   unsigned int i;
4575   unsigned int size = elf_header.e_shentsize;
4576   unsigned int num = probe ? 1 : elf_header.e_shnum;
4577
4578   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4579   if (size == 0 || num == 0)
4580     return FALSE;
4581   if (size < sizeof * shdrs)
4582     {
4583       if (! probe)
4584         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4585       return FALSE;
4586     }
4587   if (! probe && size > sizeof * shdrs)
4588     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4589
4590   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4591                                             size, num,
4592                                             probe ? NULL : _("section headers"));
4593   if (shdrs == NULL)
4594     return FALSE;
4595
4596   if (section_headers != NULL)
4597     free (section_headers);
4598   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4599                                                    sizeof (Elf_Internal_Shdr));
4600   if (section_headers == NULL)
4601     {
4602       if (! probe)
4603         error (_("Out of memory\n"));
4604       return FALSE;
4605     }
4606
4607   for (i = 0, internal = section_headers;
4608        i < num;
4609        i++, internal++)
4610     {
4611       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4612       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4613       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4614       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4615       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4616       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4617       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4618       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4619       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4620       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4621     }
4622
4623   free (shdrs);
4624   return TRUE;
4625 }
4626
4627 static Elf_Internal_Sym *
4628 get_32bit_elf_symbols (FILE * file,
4629                        Elf_Internal_Shdr * section,
4630                        unsigned long * num_syms_return)
4631 {
4632   unsigned long number = 0;
4633   Elf32_External_Sym * esyms = NULL;
4634   Elf_External_Sym_Shndx * shndx = NULL;
4635   Elf_Internal_Sym * isyms = NULL;
4636   Elf_Internal_Sym * psym;
4637   unsigned int j;
4638
4639   /* Run some sanity checks first.  */
4640   if (section->sh_entsize == 0)
4641     {
4642       error (_("sh_entsize is zero\n"));
4643       goto exit_point;
4644     }
4645
4646   if (section->sh_size > current_file_size)
4647     {
4648       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4649              SECTION_NAME (section), (unsigned long) section->sh_size);
4650       goto exit_point;
4651     }
4652
4653   number = section->sh_size / section->sh_entsize;
4654
4655   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4656     {
4657       error (_("Invalid sh_entsize\n"));
4658       goto exit_point;
4659     }
4660
4661   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4662                                            section->sh_size, _("symbols"));
4663   if (esyms == NULL)
4664     goto exit_point;
4665
4666   shndx = NULL;
4667   if (symtab_shndx_hdr != NULL
4668       && (symtab_shndx_hdr->sh_link
4669           == (unsigned long) (section - section_headers)))
4670     {
4671       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4672                                                    symtab_shndx_hdr->sh_offset,
4673                                                    1, symtab_shndx_hdr->sh_size,
4674                                                    _("symbol table section indicies"));
4675       if (shndx == NULL)
4676         goto exit_point;
4677     }
4678
4679   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4680
4681   if (isyms == NULL)
4682     {
4683       error (_("Out of memory\n"));
4684       goto exit_point;
4685     }
4686
4687   for (j = 0, psym = isyms; j < number; j++, psym++)
4688     {
4689       psym->st_name  = BYTE_GET (esyms[j].st_name);
4690       psym->st_value = BYTE_GET (esyms[j].st_value);
4691       psym->st_size  = BYTE_GET (esyms[j].st_size);
4692       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4693       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4694         psym->st_shndx
4695           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4696       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4697         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4698       psym->st_info  = BYTE_GET (esyms[j].st_info);
4699       psym->st_other = BYTE_GET (esyms[j].st_other);
4700     }
4701
4702  exit_point:
4703   if (shndx != NULL)
4704     free (shndx);
4705   if (esyms != NULL)
4706     free (esyms);
4707
4708   if (num_syms_return != NULL)
4709     * num_syms_return = isyms == NULL ? 0 : number;
4710
4711   return isyms;
4712 }
4713
4714 static Elf_Internal_Sym *
4715 get_64bit_elf_symbols (FILE * file,
4716                        Elf_Internal_Shdr * section,
4717                        unsigned long * num_syms_return)
4718 {
4719   unsigned long number = 0;
4720   Elf64_External_Sym * esyms = NULL;
4721   Elf_External_Sym_Shndx * shndx = NULL;
4722   Elf_Internal_Sym * isyms = NULL;
4723   Elf_Internal_Sym * psym;
4724   unsigned int j;
4725
4726   /* Run some sanity checks first.  */
4727   if (section->sh_entsize == 0)
4728     {
4729       error (_("sh_entsize is zero\n"));
4730       goto exit_point;
4731     }
4732
4733   if (section->sh_size > current_file_size)
4734     {
4735       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4736              SECTION_NAME (section), (unsigned long) section->sh_size);
4737       goto exit_point;
4738     }
4739
4740   number = section->sh_size / section->sh_entsize;
4741
4742   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4743     {
4744       error (_("Invalid sh_entsize\n"));
4745       goto exit_point;
4746     }
4747
4748   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4749                                            section->sh_size, _("symbols"));
4750   if (!esyms)
4751     goto exit_point;
4752
4753   if (symtab_shndx_hdr != NULL
4754       && (symtab_shndx_hdr->sh_link
4755           == (unsigned long) (section - section_headers)))
4756     {
4757       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4758                                                    symtab_shndx_hdr->sh_offset,
4759                                                    1, symtab_shndx_hdr->sh_size,
4760                                                    _("symbol table section indicies"));
4761       if (shndx == NULL)
4762         goto exit_point;
4763     }
4764
4765   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4766
4767   if (isyms == NULL)
4768     {
4769       error (_("Out of memory\n"));
4770       goto exit_point;
4771     }
4772
4773   for (j = 0, psym = isyms; j < number; j++, psym++)
4774     {
4775       psym->st_name  = BYTE_GET (esyms[j].st_name);
4776       psym->st_info  = BYTE_GET (esyms[j].st_info);
4777       psym->st_other = BYTE_GET (esyms[j].st_other);
4778       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4779
4780       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4781         psym->st_shndx
4782           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4783       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4784         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4785
4786       psym->st_value = BYTE_GET (esyms[j].st_value);
4787       psym->st_size  = BYTE_GET (esyms[j].st_size);
4788     }
4789
4790  exit_point:
4791   if (shndx != NULL)
4792     free (shndx);
4793   if (esyms != NULL)
4794     free (esyms);
4795
4796   if (num_syms_return != NULL)
4797     * num_syms_return = isyms == NULL ? 0 : number;
4798
4799   return isyms;
4800 }
4801
4802 static const char *
4803 get_elf_section_flags (bfd_vma sh_flags)
4804 {
4805   static char buff[1024];
4806   char * p = buff;
4807   int field_size = is_32bit_elf ? 8 : 16;
4808   int sindex;
4809   int size = sizeof (buff) - (field_size + 4 + 1);
4810   bfd_vma os_flags = 0;
4811   bfd_vma proc_flags = 0;
4812   bfd_vma unknown_flags = 0;
4813   static const struct
4814     {
4815       const char * str;
4816       int len;
4817     }
4818   flags [] =
4819     {
4820       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4821       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4822       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4823       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4824       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4825       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4826       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4827       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4828       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4829       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4830       /* IA-64 specific.  */
4831       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4832       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4833       /* IA-64 OpenVMS specific.  */
4834       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4835       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4836       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4837       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4838       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4839       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4840       /* Generic.  */
4841       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4842       /* SPARC specific.  */
4843       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4844     };
4845
4846   if (do_section_details)
4847     {
4848       sprintf (buff, "[%*.*lx]: ",
4849                field_size, field_size, (unsigned long) sh_flags);
4850       p += field_size + 4;
4851     }
4852
4853   while (sh_flags)
4854     {
4855       bfd_vma flag;
4856
4857       flag = sh_flags & - sh_flags;
4858       sh_flags &= ~ flag;
4859
4860       if (do_section_details)
4861         {
4862           switch (flag)
4863             {
4864             case SHF_WRITE:             sindex = 0; break;
4865             case SHF_ALLOC:             sindex = 1; break;
4866             case SHF_EXECINSTR:         sindex = 2; break;
4867             case SHF_MERGE:             sindex = 3; break;
4868             case SHF_STRINGS:           sindex = 4; break;
4869             case SHF_INFO_LINK:         sindex = 5; break;
4870             case SHF_LINK_ORDER:        sindex = 6; break;
4871             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4872             case SHF_GROUP:             sindex = 8; break;
4873             case SHF_TLS:               sindex = 9; break;
4874             case SHF_EXCLUDE:           sindex = 18; break;
4875
4876             default:
4877               sindex = -1;
4878               switch (elf_header.e_machine)
4879                 {
4880                 case EM_IA_64:
4881                   if (flag == SHF_IA_64_SHORT)
4882                     sindex = 10;
4883                   else if (flag == SHF_IA_64_NORECOV)
4884                     sindex = 11;
4885 #ifdef BFD64
4886                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4887                     switch (flag)
4888                       {
4889                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4890                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4891                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4892                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4893                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4894                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4895                       default:                        break;
4896                       }
4897 #endif
4898                   break;
4899
4900                 case EM_386:
4901                 case EM_486:
4902                 case EM_X86_64:
4903                 case EM_L1OM:
4904                 case EM_K1OM:
4905                 case EM_OLD_SPARCV9:
4906                 case EM_SPARC32PLUS:
4907                 case EM_SPARCV9:
4908                 case EM_SPARC:
4909                   if (flag == SHF_ORDERED)
4910                     sindex = 19;
4911                   break;
4912                 default:
4913                   break;
4914                 }
4915             }
4916
4917           if (sindex != -1)
4918             {
4919               if (p != buff + field_size + 4)
4920                 {
4921                   if (size < (10 + 2))
4922                     abort ();
4923                   size -= 2;
4924                   *p++ = ',';
4925                   *p++ = ' ';
4926                 }
4927
4928               size -= flags [sindex].len;
4929               p = stpcpy (p, flags [sindex].str);
4930             }
4931           else if (flag & SHF_MASKOS)
4932             os_flags |= flag;
4933           else if (flag & SHF_MASKPROC)
4934             proc_flags |= flag;
4935           else
4936             unknown_flags |= flag;
4937         }
4938       else
4939         {
4940           switch (flag)
4941             {
4942             case SHF_WRITE:             *p = 'W'; break;
4943             case SHF_ALLOC:             *p = 'A'; break;
4944             case SHF_EXECINSTR:         *p = 'X'; break;
4945             case SHF_MERGE:             *p = 'M'; break;
4946             case SHF_STRINGS:           *p = 'S'; break;
4947             case SHF_INFO_LINK:         *p = 'I'; break;
4948             case SHF_LINK_ORDER:        *p = 'L'; break;
4949             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4950             case SHF_GROUP:             *p = 'G'; break;
4951             case SHF_TLS:               *p = 'T'; break;
4952             case SHF_EXCLUDE:           *p = 'E'; break;
4953
4954             default:
4955               if ((elf_header.e_machine == EM_X86_64
4956                    || elf_header.e_machine == EM_L1OM
4957                    || elf_header.e_machine == EM_K1OM)
4958                   && flag == SHF_X86_64_LARGE)
4959                 *p = 'l';
4960               else if (flag & SHF_MASKOS)
4961                 {
4962                   *p = 'o';
4963                   sh_flags &= ~ SHF_MASKOS;
4964                 }
4965               else if (flag & SHF_MASKPROC)
4966                 {
4967                   *p = 'p';
4968                   sh_flags &= ~ SHF_MASKPROC;
4969                 }
4970               else
4971                 *p = 'x';
4972               break;
4973             }
4974           p++;
4975         }
4976     }
4977
4978   if (do_section_details)
4979     {
4980       if (os_flags)
4981         {
4982           size -= 5 + field_size;
4983           if (p != buff + field_size + 4)
4984             {
4985               if (size < (2 + 1))
4986                 abort ();
4987               size -= 2;
4988               *p++ = ',';
4989               *p++ = ' ';
4990             }
4991           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4992                    (unsigned long) os_flags);
4993           p += 5 + field_size;
4994         }
4995       if (proc_flags)
4996         {
4997           size -= 7 + field_size;
4998           if (p != buff + field_size + 4)
4999             {
5000               if (size < (2 + 1))
5001                 abort ();
5002               size -= 2;
5003               *p++ = ',';
5004               *p++ = ' ';
5005             }
5006           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5007                    (unsigned long) proc_flags);
5008           p += 7 + field_size;
5009         }
5010       if (unknown_flags)
5011         {
5012           size -= 10 + field_size;
5013           if (p != buff + field_size + 4)
5014             {
5015               if (size < (2 + 1))
5016                 abort ();
5017               size -= 2;
5018               *p++ = ',';
5019               *p++ = ' ';
5020             }
5021           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5022                    (unsigned long) unknown_flags);
5023           p += 10 + field_size;
5024         }
5025     }
5026
5027   *p = '\0';
5028   return buff;
5029 }
5030
5031 static int
5032 process_section_headers (FILE * file)
5033 {
5034   Elf_Internal_Shdr * section;
5035   unsigned int i;
5036
5037   section_headers = NULL;
5038
5039   if (elf_header.e_shnum == 0)
5040     {
5041       /* PR binutils/12467.  */
5042       if (elf_header.e_shoff != 0)
5043         warn (_("possibly corrupt ELF file header - it has a non-zero"
5044                 " section header offset, but no section headers\n"));
5045       else if (do_sections)
5046         printf (_("\nThere are no sections in this file.\n"));
5047
5048       return 1;
5049     }
5050
5051   if (do_sections && !do_header)
5052     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5053             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5054
5055   if (is_32bit_elf)
5056     {
5057       if (! get_32bit_section_headers (file, FALSE))
5058         return 0;
5059     }
5060   else if (! get_64bit_section_headers (file, FALSE))
5061     return 0;
5062
5063   /* Read in the string table, so that we have names to display.  */
5064   if (elf_header.e_shstrndx != SHN_UNDEF
5065        && elf_header.e_shstrndx < elf_header.e_shnum)
5066     {
5067       section = section_headers + elf_header.e_shstrndx;
5068
5069       if (section->sh_size != 0)
5070         {
5071           string_table = (char *) get_data (NULL, file, section->sh_offset,
5072                                             1, section->sh_size,
5073                                             _("string table"));
5074
5075           string_table_length = string_table != NULL ? section->sh_size : 0;
5076         }
5077     }
5078
5079   /* Scan the sections for the dynamic symbol table
5080      and dynamic string table and debug sections.  */
5081   dynamic_symbols = NULL;
5082   dynamic_strings = NULL;
5083   dynamic_syminfo = NULL;
5084   symtab_shndx_hdr = NULL;
5085
5086   eh_addr_size = is_32bit_elf ? 4 : 8;
5087   switch (elf_header.e_machine)
5088     {
5089     case EM_MIPS:
5090     case EM_MIPS_RS3_LE:
5091       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5092          FDE addresses.  However, the ABI also has a semi-official ILP32
5093          variant for which the normal FDE address size rules apply.
5094
5095          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5096          section, where XX is the size of longs in bits.  Unfortunately,
5097          earlier compilers provided no way of distinguishing ILP32 objects
5098          from LP64 objects, so if there's any doubt, we should assume that
5099          the official LP64 form is being used.  */
5100       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5101           && find_section (".gcc_compiled_long32") == NULL)
5102         eh_addr_size = 8;
5103       break;
5104
5105     case EM_H8_300:
5106     case EM_H8_300H:
5107       switch (elf_header.e_flags & EF_H8_MACH)
5108         {
5109         case E_H8_MACH_H8300:
5110         case E_H8_MACH_H8300HN:
5111         case E_H8_MACH_H8300SN:
5112         case E_H8_MACH_H8300SXN:
5113           eh_addr_size = 2;
5114           break;
5115         case E_H8_MACH_H8300H:
5116         case E_H8_MACH_H8300S:
5117         case E_H8_MACH_H8300SX:
5118           eh_addr_size = 4;
5119           break;
5120         }
5121       break;
5122
5123     case EM_M32C_OLD:
5124     case EM_M32C:
5125       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5126         {
5127         case EF_M32C_CPU_M16C:
5128           eh_addr_size = 2;
5129           break;
5130         }
5131       break;
5132     }
5133
5134 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5135   do                                                                    \
5136     {                                                                   \
5137       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5138       if (section->sh_entsize != expected_entsize)                      \
5139         {                                                               \
5140           char buf[40];                                                 \
5141           sprintf_vma (buf, section->sh_entsize);                       \
5142           /* Note: coded this way so that there is a single string for  \
5143              translation.  */ \
5144           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5145           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5146                    (unsigned) expected_entsize);                        \
5147           section->sh_entsize = expected_entsize;                       \
5148         }                                                               \
5149     }                                                                   \
5150   while (0)
5151
5152 #define CHECK_ENTSIZE(section, i, type)                                 \
5153   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5154                         sizeof (Elf64_External_##type))
5155
5156   for (i = 0, section = section_headers;
5157        i < elf_header.e_shnum;
5158        i++, section++)
5159     {
5160       char * name = SECTION_NAME (section);
5161
5162       if (section->sh_type == SHT_DYNSYM)
5163         {
5164           if (dynamic_symbols != NULL)
5165             {
5166               error (_("File contains multiple dynamic symbol tables\n"));
5167               continue;
5168             }
5169
5170           CHECK_ENTSIZE (section, i, Sym);
5171           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5172         }
5173       else if (section->sh_type == SHT_STRTAB
5174                && streq (name, ".dynstr"))
5175         {
5176           if (dynamic_strings != NULL)
5177             {
5178               error (_("File contains multiple dynamic string tables\n"));
5179               continue;
5180             }
5181
5182           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5183                                                1, section->sh_size,
5184                                                _("dynamic strings"));
5185           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5186         }
5187       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5188         {
5189           if (symtab_shndx_hdr != NULL)
5190             {
5191               error (_("File contains multiple symtab shndx tables\n"));
5192               continue;
5193             }
5194           symtab_shndx_hdr = section;
5195         }
5196       else if (section->sh_type == SHT_SYMTAB)
5197         CHECK_ENTSIZE (section, i, Sym);
5198       else if (section->sh_type == SHT_GROUP)
5199         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5200       else if (section->sh_type == SHT_REL)
5201         CHECK_ENTSIZE (section, i, Rel);
5202       else if (section->sh_type == SHT_RELA)
5203         CHECK_ENTSIZE (section, i, Rela);
5204       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5205                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5206                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5207                 || do_debug_str || do_debug_loc || do_debug_ranges
5208                 || do_debug_addr || do_debug_cu_index)
5209                && (const_strneq (name, ".debug_")
5210                    || const_strneq (name, ".zdebug_")))
5211         {
5212           if (name[1] == 'z')
5213             name += sizeof (".zdebug_") - 1;
5214           else
5215             name += sizeof (".debug_") - 1;
5216
5217           if (do_debugging
5218               || (do_debug_info     && const_strneq (name, "info"))
5219               || (do_debug_info     && const_strneq (name, "types"))
5220               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5221               || (do_debug_lines    && strcmp (name, "line") == 0)
5222               || (do_debug_lines    && const_strneq (name, "line."))
5223               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5224               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5225               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5226               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5227               || (do_debug_aranges  && const_strneq (name, "aranges"))
5228               || (do_debug_ranges   && const_strneq (name, "ranges"))
5229               || (do_debug_frames   && const_strneq (name, "frame"))
5230               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5231               || (do_debug_macinfo  && const_strneq (name, "macro"))
5232               || (do_debug_str      && const_strneq (name, "str"))
5233               || (do_debug_loc      && const_strneq (name, "loc"))
5234               || (do_debug_addr     && const_strneq (name, "addr"))
5235               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5236               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5237               )
5238             request_dump_bynumber (i, DEBUG_DUMP);
5239         }
5240       /* Linkonce section to be combined with .debug_info at link time.  */
5241       else if ((do_debugging || do_debug_info)
5242                && const_strneq (name, ".gnu.linkonce.wi."))
5243         request_dump_bynumber (i, DEBUG_DUMP);
5244       else if (do_debug_frames && streq (name, ".eh_frame"))
5245         request_dump_bynumber (i, DEBUG_DUMP);
5246       else if (do_gdb_index && streq (name, ".gdb_index"))
5247         request_dump_bynumber (i, DEBUG_DUMP);
5248       /* Trace sections for Itanium VMS.  */
5249       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5250                 || do_trace_aranges)
5251                && const_strneq (name, ".trace_"))
5252         {
5253           name += sizeof (".trace_") - 1;
5254
5255           if (do_debugging
5256               || (do_trace_info     && streq (name, "info"))
5257               || (do_trace_abbrevs  && streq (name, "abbrev"))
5258               || (do_trace_aranges  && streq (name, "aranges"))
5259               )
5260             request_dump_bynumber (i, DEBUG_DUMP);
5261         }
5262
5263     }
5264
5265   if (! do_sections)
5266     return 1;
5267
5268   if (elf_header.e_shnum > 1)
5269     printf (_("\nSection Headers:\n"));
5270   else
5271     printf (_("\nSection Header:\n"));
5272
5273   if (is_32bit_elf)
5274     {
5275       if (do_section_details)
5276         {
5277           printf (_("  [Nr] Name\n"));
5278           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5279         }
5280       else
5281         printf
5282           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5283     }
5284   else if (do_wide)
5285     {
5286       if (do_section_details)
5287         {
5288           printf (_("  [Nr] Name\n"));
5289           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5290         }
5291       else
5292         printf
5293           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5294     }
5295   else
5296     {
5297       if (do_section_details)
5298         {
5299           printf (_("  [Nr] Name\n"));
5300           printf (_("       Type              Address          Offset            Link\n"));
5301           printf (_("       Size              EntSize          Info              Align\n"));
5302         }
5303       else
5304         {
5305           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5306           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5307         }
5308     }
5309
5310   if (do_section_details)
5311     printf (_("       Flags\n"));
5312
5313   for (i = 0, section = section_headers;
5314        i < elf_header.e_shnum;
5315        i++, section++)
5316     {
5317       printf ("  [%2u] ", i);
5318       if (do_section_details)
5319         {
5320           print_symbol (INT_MAX, SECTION_NAME (section));
5321           printf ("\n      ");
5322         }
5323       else
5324         {
5325           print_symbol (-17, SECTION_NAME (section));
5326         }
5327
5328       printf (do_wide ? " %-15s " : " %-15.15s ",
5329               get_section_type_name (section->sh_type));
5330
5331       if (is_32bit_elf)
5332         {
5333           const char * link_too_big = NULL;
5334
5335           print_vma (section->sh_addr, LONG_HEX);
5336
5337           printf ( " %6.6lx %6.6lx %2.2lx",
5338                    (unsigned long) section->sh_offset,
5339                    (unsigned long) section->sh_size,
5340                    (unsigned long) section->sh_entsize);
5341
5342           if (do_section_details)
5343             fputs ("  ", stdout);
5344           else
5345             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5346
5347           if (section->sh_link >= elf_header.e_shnum)
5348             {
5349               link_too_big = "";
5350               /* The sh_link value is out of range.  Normally this indicates
5351                  an error but it can have special values in Solaris binaries.  */
5352               switch (elf_header.e_machine)
5353                 {
5354                 case EM_386:
5355                 case EM_486:
5356                 case EM_X86_64:
5357                 case EM_L1OM:
5358                 case EM_K1OM:
5359                 case EM_OLD_SPARCV9:
5360                 case EM_SPARC32PLUS:
5361                 case EM_SPARCV9:
5362                 case EM_SPARC:
5363                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5364                     link_too_big = "BEFORE";
5365                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5366                     link_too_big = "AFTER";
5367                   break;
5368                 default:
5369                   break;
5370                 }
5371             }
5372
5373           if (do_section_details)
5374             {
5375               if (link_too_big != NULL && * link_too_big)
5376                 printf ("<%s> ", link_too_big);
5377               else
5378                 printf ("%2u ", section->sh_link);
5379               printf ("%3u %2lu\n", section->sh_info,
5380                       (unsigned long) section->sh_addralign);
5381             }
5382           else
5383             printf ("%2u %3u %2lu\n",
5384                     section->sh_link,
5385                     section->sh_info,
5386                     (unsigned long) section->sh_addralign);
5387
5388           if (link_too_big && ! * link_too_big)
5389             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5390                   i, section->sh_link);
5391         }
5392       else if (do_wide)
5393         {
5394           print_vma (section->sh_addr, LONG_HEX);
5395
5396           if ((long) section->sh_offset == section->sh_offset)
5397             printf (" %6.6lx", (unsigned long) section->sh_offset);
5398           else
5399             {
5400               putchar (' ');
5401               print_vma (section->sh_offset, LONG_HEX);
5402             }
5403
5404           if ((unsigned long) section->sh_size == section->sh_size)
5405             printf (" %6.6lx", (unsigned long) section->sh_size);
5406           else
5407             {
5408               putchar (' ');
5409               print_vma (section->sh_size, LONG_HEX);
5410             }
5411
5412           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5413             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5414           else
5415             {
5416               putchar (' ');
5417               print_vma (section->sh_entsize, LONG_HEX);
5418             }
5419
5420           if (do_section_details)
5421             fputs ("  ", stdout);
5422           else
5423             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5424
5425           printf ("%2u %3u ", section->sh_link, section->sh_info);
5426
5427           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5428             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5429           else
5430             {
5431               print_vma (section->sh_addralign, DEC);
5432               putchar ('\n');
5433             }
5434         }
5435       else if (do_section_details)
5436         {
5437           printf ("       %-15.15s  ",
5438                   get_section_type_name (section->sh_type));
5439           print_vma (section->sh_addr, LONG_HEX);
5440           if ((long) section->sh_offset == section->sh_offset)
5441             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5442           else
5443             {
5444               printf ("  ");
5445               print_vma (section->sh_offset, LONG_HEX);
5446             }
5447           printf ("  %u\n       ", section->sh_link);
5448           print_vma (section->sh_size, LONG_HEX);
5449           putchar (' ');
5450           print_vma (section->sh_entsize, LONG_HEX);
5451
5452           printf ("  %-16u  %lu\n",
5453                   section->sh_info,
5454                   (unsigned long) section->sh_addralign);
5455         }
5456       else
5457         {
5458           putchar (' ');
5459           print_vma (section->sh_addr, LONG_HEX);
5460           if ((long) section->sh_offset == section->sh_offset)
5461             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5462           else
5463             {
5464               printf ("  ");
5465               print_vma (section->sh_offset, LONG_HEX);
5466             }
5467           printf ("\n       ");
5468           print_vma (section->sh_size, LONG_HEX);
5469           printf ("  ");
5470           print_vma (section->sh_entsize, LONG_HEX);
5471
5472           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5473
5474           printf ("     %2u   %3u     %lu\n",
5475                   section->sh_link,
5476                   section->sh_info,
5477                   (unsigned long) section->sh_addralign);
5478         }
5479
5480       if (do_section_details)
5481         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5482     }
5483
5484   if (!do_section_details)
5485     {
5486       if (elf_header.e_machine == EM_X86_64
5487           || elf_header.e_machine == EM_L1OM
5488           || elf_header.e_machine == EM_K1OM)
5489         printf (_("Key to Flags:\n\
5490   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5491   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5492   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5493       else
5494         printf (_("Key to Flags:\n\
5495   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5496   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5497   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5498     }
5499
5500   return 1;
5501 }
5502
5503 static const char *
5504 get_group_flags (unsigned int flags)
5505 {
5506   static char buff[32];
5507   switch (flags)
5508     {
5509     case 0:
5510       return "";
5511
5512     case GRP_COMDAT:
5513       return "COMDAT ";
5514
5515    default:
5516       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5517       break;
5518     }
5519   return buff;
5520 }
5521
5522 static int
5523 process_section_groups (FILE * file)
5524 {
5525   Elf_Internal_Shdr * section;
5526   unsigned int i;
5527   struct group * group;
5528   Elf_Internal_Shdr * symtab_sec;
5529   Elf_Internal_Shdr * strtab_sec;
5530   Elf_Internal_Sym * symtab;
5531   unsigned long num_syms;
5532   char * strtab;
5533   size_t strtab_size;
5534
5535   /* Don't process section groups unless needed.  */
5536   if (!do_unwind && !do_section_groups)
5537     return 1;
5538
5539   if (elf_header.e_shnum == 0)
5540     {
5541       if (do_section_groups)
5542         printf (_("\nThere are no sections to group in this file.\n"));
5543
5544       return 1;
5545     }
5546
5547   if (section_headers == NULL)
5548     {
5549       error (_("Section headers are not available!\n"));
5550       /* PR 13622: This can happen with a corrupt ELF header.  */
5551       return 0;
5552     }
5553
5554   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5555                                                      sizeof (struct group *));
5556
5557   if (section_headers_groups == NULL)
5558     {
5559       error (_("Out of memory\n"));
5560       return 0;
5561     }
5562
5563   /* Scan the sections for the group section.  */
5564   group_count = 0;
5565   for (i = 0, section = section_headers;
5566        i < elf_header.e_shnum;
5567        i++, section++)
5568     if (section->sh_type == SHT_GROUP)
5569       group_count++;
5570
5571   if (group_count == 0)
5572     {
5573       if (do_section_groups)
5574         printf (_("\nThere are no section groups in this file.\n"));
5575
5576       return 1;
5577     }
5578
5579   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5580
5581   if (section_groups == NULL)
5582     {
5583       error (_("Out of memory\n"));
5584       return 0;
5585     }
5586
5587   symtab_sec = NULL;
5588   strtab_sec = NULL;
5589   symtab = NULL;
5590   num_syms = 0;
5591   strtab = NULL;
5592   strtab_size = 0;
5593   for (i = 0, section = section_headers, group = section_groups;
5594        i < elf_header.e_shnum;
5595        i++, section++)
5596     {
5597       if (section->sh_type == SHT_GROUP)
5598         {
5599           char * name = SECTION_NAME (section);
5600           char * group_name;
5601           unsigned char * start;
5602           unsigned char * indices;
5603           unsigned int entry, j, size;
5604           Elf_Internal_Shdr * sec;
5605           Elf_Internal_Sym * sym;
5606
5607           /* Get the symbol table.  */
5608           if (section->sh_link >= elf_header.e_shnum
5609               || ((sec = section_headers + section->sh_link)->sh_type
5610                   != SHT_SYMTAB))
5611             {
5612               error (_("Bad sh_link in group section `%s'\n"), name);
5613               continue;
5614             }
5615
5616           if (symtab_sec != sec)
5617             {
5618               symtab_sec = sec;
5619               if (symtab)
5620                 free (symtab);
5621               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5622             }
5623
5624           if (symtab == NULL)
5625             {
5626               error (_("Corrupt header in group section `%s'\n"), name);
5627               continue;
5628             }
5629
5630           if (section->sh_info >= num_syms)
5631             {
5632               error (_("Bad sh_info in group section `%s'\n"), name);
5633               continue;
5634             }
5635
5636           sym = symtab + section->sh_info;
5637
5638           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5639             {
5640               if (sym->st_shndx == 0
5641                   || sym->st_shndx >= elf_header.e_shnum)
5642                 {
5643                   error (_("Bad sh_info in group section `%s'\n"), name);
5644                   continue;
5645                 }
5646
5647               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5648               strtab_sec = NULL;
5649               if (strtab)
5650                 free (strtab);
5651               strtab = NULL;
5652               strtab_size = 0;
5653             }
5654           else
5655             {
5656               /* Get the string table.  */
5657               if (symtab_sec->sh_link >= elf_header.e_shnum)
5658                 {
5659                   strtab_sec = NULL;
5660                   if (strtab)
5661                     free (strtab);
5662                   strtab = NULL;
5663                   strtab_size = 0;
5664                 }
5665               else if (strtab_sec
5666                        != (sec = section_headers + symtab_sec->sh_link))
5667                 {
5668                   strtab_sec = sec;
5669                   if (strtab)
5670                     free (strtab);
5671                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5672                                               1, strtab_sec->sh_size,
5673                                               _("string table"));
5674                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5675                 }
5676               group_name = sym->st_name < strtab_size
5677                 ? strtab + sym->st_name : _("<corrupt>");
5678             }
5679
5680           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5681                                               1, section->sh_size,
5682                                               _("section data"));
5683           if (start == NULL)
5684             continue;
5685
5686           indices = start;
5687           size = (section->sh_size / section->sh_entsize) - 1;
5688           entry = byte_get (indices, 4);
5689           indices += 4;
5690
5691           if (do_section_groups)
5692             {
5693               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5694                       get_group_flags (entry), i, name, group_name, size);
5695
5696               printf (_("   [Index]    Name\n"));
5697             }
5698
5699           group->group_index = i;
5700
5701           for (j = 0; j < size; j++)
5702             {
5703               struct group_list * g;
5704
5705               entry = byte_get (indices, 4);
5706               indices += 4;
5707
5708               if (entry >= elf_header.e_shnum)
5709                 {
5710                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5711                          entry, i, elf_header.e_shnum - 1);
5712                   continue;
5713                 }
5714
5715               if (section_headers_groups [entry] != NULL)
5716                 {
5717                   if (entry)
5718                     {
5719                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5720                              entry, i,
5721                              section_headers_groups [entry]->group_index);
5722                       continue;
5723                     }
5724                   else
5725                     {
5726                       /* Intel C/C++ compiler may put section 0 in a
5727                          section group. We just warn it the first time
5728                          and ignore it afterwards.  */
5729                       static int warned = 0;
5730                       if (!warned)
5731                         {
5732                           error (_("section 0 in group section [%5u]\n"),
5733                                  section_headers_groups [entry]->group_index);
5734                           warned++;
5735                         }
5736                     }
5737                 }
5738
5739               section_headers_groups [entry] = group;
5740
5741               if (do_section_groups)
5742                 {
5743                   sec = section_headers + entry;
5744                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5745                 }
5746
5747               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5748               g->section_index = entry;
5749               g->next = group->root;
5750               group->root = g;
5751             }
5752
5753           if (start)
5754             free (start);
5755
5756           group++;
5757         }
5758     }
5759
5760   if (symtab)
5761     free (symtab);
5762   if (strtab)
5763     free (strtab);
5764   return 1;
5765 }
5766
5767 /* Data used to display dynamic fixups.  */
5768
5769 struct ia64_vms_dynfixup
5770 {
5771   bfd_vma needed_ident;         /* Library ident number.  */
5772   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5773   bfd_vma fixup_needed;         /* Index of the library.  */
5774   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5775   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5776 };
5777
5778 /* Data used to display dynamic relocations.  */
5779
5780 struct ia64_vms_dynimgrela
5781 {
5782   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5783   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5784 };
5785
5786 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5787    library).  */
5788
5789 static void
5790 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5791                               const char *strtab, unsigned int strtab_sz)
5792 {
5793   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5794   long i;
5795   const char *lib_name;
5796
5797   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5798                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5799                    _("dynamic section image fixups"));
5800   if (!imfs)
5801     return;
5802
5803   if (fixup->needed < strtab_sz)
5804     lib_name = strtab + fixup->needed;
5805   else
5806     {
5807       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5808             (unsigned long) fixup->needed);
5809       lib_name = "???";
5810     }
5811   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5812           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5813   printf
5814     (_("Seg Offset           Type                             SymVec DataType\n"));
5815
5816   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5817     {
5818       unsigned int type;
5819       const char *rtype;
5820
5821       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5822       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5823       type = BYTE_GET (imfs [i].type);
5824       rtype = elf_ia64_reloc_type (type);
5825       if (rtype == NULL)
5826         printf (" 0x%08x                       ", type);
5827       else
5828         printf (" %-32s ", rtype);
5829       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5830       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5831     }
5832
5833   free (imfs);
5834 }
5835
5836 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5837
5838 static void
5839 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5840 {
5841   Elf64_External_VMS_IMAGE_RELA *imrs;
5842   long i;
5843
5844   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5845                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5846                    _("dynamic section image relocations"));
5847   if (!imrs)
5848     return;
5849
5850   printf (_("\nImage relocs\n"));
5851   printf
5852     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5853
5854   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5855     {
5856       unsigned int type;
5857       const char *rtype;
5858
5859       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5860       printf ("%08" BFD_VMA_FMT "x ",
5861               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5862       type = BYTE_GET (imrs [i].type);
5863       rtype = elf_ia64_reloc_type (type);
5864       if (rtype == NULL)
5865         printf ("0x%08x                      ", type);
5866       else
5867         printf ("%-31s ", rtype);
5868       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5869       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5870       printf ("%08" BFD_VMA_FMT "x\n",
5871               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5872     }
5873
5874   free (imrs);
5875 }
5876
5877 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5878
5879 static int
5880 process_ia64_vms_dynamic_relocs (FILE *file)
5881 {
5882   struct ia64_vms_dynfixup fixup;
5883   struct ia64_vms_dynimgrela imgrela;
5884   Elf_Internal_Dyn *entry;
5885   int res = 0;
5886   bfd_vma strtab_off = 0;
5887   bfd_vma strtab_sz = 0;
5888   char *strtab = NULL;
5889
5890   memset (&fixup, 0, sizeof (fixup));
5891   memset (&imgrela, 0, sizeof (imgrela));
5892
5893   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5894   for (entry = dynamic_section;
5895        entry < dynamic_section + dynamic_nent;
5896        entry++)
5897     {
5898       switch (entry->d_tag)
5899         {
5900         case DT_IA_64_VMS_STRTAB_OFFSET:
5901           strtab_off = entry->d_un.d_val;
5902           break;
5903         case DT_STRSZ:
5904           strtab_sz = entry->d_un.d_val;
5905           if (strtab == NULL)
5906             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5907                                1, strtab_sz, _("dynamic string section"));
5908           break;
5909
5910         case DT_IA_64_VMS_NEEDED_IDENT:
5911           fixup.needed_ident = entry->d_un.d_val;
5912           break;
5913         case DT_NEEDED:
5914           fixup.needed = entry->d_un.d_val;
5915           break;
5916         case DT_IA_64_VMS_FIXUP_NEEDED:
5917           fixup.fixup_needed = entry->d_un.d_val;
5918           break;
5919         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5920           fixup.fixup_rela_cnt = entry->d_un.d_val;
5921           break;
5922         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5923           fixup.fixup_rela_off = entry->d_un.d_val;
5924           res++;
5925           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5926           break;
5927
5928         case DT_IA_64_VMS_IMG_RELA_CNT:
5929           imgrela.img_rela_cnt = entry->d_un.d_val;
5930           break;
5931         case DT_IA_64_VMS_IMG_RELA_OFF:
5932           imgrela.img_rela_off = entry->d_un.d_val;
5933           res++;
5934           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5935           break;
5936
5937         default:
5938           break;
5939         }
5940     }
5941
5942   if (strtab != NULL)
5943     free (strtab);
5944
5945   return res;
5946 }
5947
5948 static struct
5949 {
5950   const char * name;
5951   int reloc;
5952   int size;
5953   int rela;
5954 } dynamic_relocations [] =
5955 {
5956     { "REL", DT_REL, DT_RELSZ, FALSE },
5957     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5958     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5959 };
5960
5961 /* Process the reloc section.  */
5962
5963 static int
5964 process_relocs (FILE * file)
5965 {
5966   unsigned long rel_size;
5967   unsigned long rel_offset;
5968
5969
5970   if (!do_reloc)
5971     return 1;
5972
5973   if (do_using_dynamic)
5974     {
5975       int is_rela;
5976       const char * name;
5977       int has_dynamic_reloc;
5978       unsigned int i;
5979
5980       has_dynamic_reloc = 0;
5981
5982       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5983         {
5984           is_rela = dynamic_relocations [i].rela;
5985           name = dynamic_relocations [i].name;
5986           rel_size = dynamic_info [dynamic_relocations [i].size];
5987           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5988
5989           has_dynamic_reloc |= rel_size;
5990
5991           if (is_rela == UNKNOWN)
5992             {
5993               if (dynamic_relocations [i].reloc == DT_JMPREL)
5994                 switch (dynamic_info[DT_PLTREL])
5995                   {
5996                   case DT_REL:
5997                     is_rela = FALSE;
5998                     break;
5999                   case DT_RELA:
6000                     is_rela = TRUE;
6001                     break;
6002                   }
6003             }
6004
6005           if (rel_size)
6006             {
6007               printf
6008                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6009                  name, rel_offset, rel_size);
6010
6011               dump_relocations (file,
6012                                 offset_from_vma (file, rel_offset, rel_size),
6013                                 rel_size,
6014                                 dynamic_symbols, num_dynamic_syms,
6015                                 dynamic_strings, dynamic_strings_length, is_rela);
6016             }
6017         }
6018
6019       if (is_ia64_vms ())
6020         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6021
6022       if (! has_dynamic_reloc)
6023         printf (_("\nThere are no dynamic relocations in this file.\n"));
6024     }
6025   else
6026     {
6027       Elf_Internal_Shdr * section;
6028       unsigned long i;
6029       int found = 0;
6030
6031       for (i = 0, section = section_headers;
6032            i < elf_header.e_shnum;
6033            i++, section++)
6034         {
6035           if (   section->sh_type != SHT_RELA
6036               && section->sh_type != SHT_REL)
6037             continue;
6038
6039           rel_offset = section->sh_offset;
6040           rel_size   = section->sh_size;
6041
6042           if (rel_size)
6043             {
6044               Elf_Internal_Shdr * strsec;
6045               int is_rela;
6046
6047               printf (_("\nRelocation section "));
6048
6049               if (string_table == NULL)
6050                 printf ("%d", section->sh_name);
6051               else
6052                 printf ("'%s'", SECTION_NAME (section));
6053
6054               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6055                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6056
6057               is_rela = section->sh_type == SHT_RELA;
6058
6059               if (section->sh_link != 0
6060                   && section->sh_link < elf_header.e_shnum)
6061                 {
6062                   Elf_Internal_Shdr * symsec;
6063                   Elf_Internal_Sym *  symtab;
6064                   unsigned long nsyms;
6065                   unsigned long strtablen = 0;
6066                   char * strtab = NULL;
6067
6068                   symsec = section_headers + section->sh_link;
6069                   if (symsec->sh_type != SHT_SYMTAB
6070                       && symsec->sh_type != SHT_DYNSYM)
6071                     continue;
6072
6073                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6074
6075                   if (symtab == NULL)
6076                     continue;
6077
6078                   if (symsec->sh_link != 0
6079                       && symsec->sh_link < elf_header.e_shnum)
6080                     {
6081                       strsec = section_headers + symsec->sh_link;
6082
6083                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6084                                                   1, strsec->sh_size,
6085                                                   _("string table"));
6086                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6087                     }
6088
6089                   dump_relocations (file, rel_offset, rel_size,
6090                                     symtab, nsyms, strtab, strtablen, is_rela);
6091                   if (strtab)
6092                     free (strtab);
6093                   free (symtab);
6094                 }
6095               else
6096                 dump_relocations (file, rel_offset, rel_size,
6097                                   NULL, 0, NULL, 0, is_rela);
6098
6099               found = 1;
6100             }
6101         }
6102
6103       if (! found)
6104         printf (_("\nThere are no relocations in this file.\n"));
6105     }
6106
6107   return 1;
6108 }
6109
6110 /* Process the unwind section.  */
6111
6112 #include "unwind-ia64.h"
6113
6114 /* An absolute address consists of a section and an offset.  If the
6115    section is NULL, the offset itself is the address, otherwise, the
6116    address equals to LOAD_ADDRESS(section) + offset.  */
6117
6118 struct absaddr
6119   {
6120     unsigned short section;
6121     bfd_vma offset;
6122   };
6123
6124 #define ABSADDR(a) \
6125   ((a).section \
6126    ? section_headers [(a).section].sh_addr + (a).offset \
6127    : (a).offset)
6128
6129 struct ia64_unw_table_entry
6130   {
6131     struct absaddr start;
6132     struct absaddr end;
6133     struct absaddr info;
6134   };
6135
6136 struct ia64_unw_aux_info
6137   {
6138
6139     struct ia64_unw_table_entry *table; /* Unwind table.  */
6140     unsigned long table_len;    /* Length of unwind table.  */
6141     unsigned char * info;       /* Unwind info.  */
6142     unsigned long info_size;    /* Size of unwind info.  */
6143     bfd_vma info_addr;          /* starting address of unwind info.  */
6144     bfd_vma seg_base;           /* Starting address of segment.  */
6145     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6146     unsigned long nsyms;        /* Number of symbols.  */
6147     char * strtab;              /* The string table.  */
6148     unsigned long strtab_size;  /* Size of string table.  */
6149   };
6150
6151 static void
6152 find_symbol_for_address (Elf_Internal_Sym * symtab,
6153                          unsigned long nsyms,
6154                          const char * strtab,
6155                          unsigned long strtab_size,
6156                          struct absaddr addr,
6157                          const char ** symname,
6158                          bfd_vma * offset)
6159 {
6160   bfd_vma dist = 0x100000;
6161   Elf_Internal_Sym * sym;
6162   Elf_Internal_Sym * best = NULL;
6163   unsigned long i;
6164
6165   REMOVE_ARCH_BITS (addr.offset);
6166
6167   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6168     {
6169       bfd_vma value = sym->st_value;
6170
6171       REMOVE_ARCH_BITS (value);
6172
6173       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6174           && sym->st_name != 0
6175           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6176           && addr.offset >= value
6177           && addr.offset - value < dist)
6178         {
6179           best = sym;
6180           dist = addr.offset - value;
6181           if (!dist)
6182             break;
6183         }
6184     }
6185
6186   if (best)
6187     {
6188       *symname = (best->st_name >= strtab_size
6189                   ? _("<corrupt>") : strtab + best->st_name);
6190       *offset = dist;
6191       return;
6192     }
6193
6194   *symname = NULL;
6195   *offset = addr.offset;
6196 }
6197
6198 static void
6199 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6200 {
6201   struct ia64_unw_table_entry * tp;
6202   int in_body;
6203
6204   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6205     {
6206       bfd_vma stamp;
6207       bfd_vma offset;
6208       const unsigned char * dp;
6209       const unsigned char * head;
6210       const char * procname;
6211
6212       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6213                                aux->strtab_size, tp->start, &procname, &offset);
6214
6215       fputs ("\n<", stdout);
6216
6217       if (procname)
6218         {
6219           fputs (procname, stdout);
6220
6221           if (offset)
6222             printf ("+%lx", (unsigned long) offset);
6223         }
6224
6225       fputs (">: [", stdout);
6226       print_vma (tp->start.offset, PREFIX_HEX);
6227       fputc ('-', stdout);
6228       print_vma (tp->end.offset, PREFIX_HEX);
6229       printf ("], info at +0x%lx\n",
6230               (unsigned long) (tp->info.offset - aux->seg_base));
6231
6232       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6233       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6234
6235       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6236               (unsigned) UNW_VER (stamp),
6237               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6238               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6239               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6240               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6241
6242       if (UNW_VER (stamp) != 1)
6243         {
6244           printf (_("\tUnknown version.\n"));
6245           continue;
6246         }
6247
6248       in_body = 0;
6249       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6250         dp = unw_decode (dp, in_body, & in_body);
6251     }
6252 }
6253
6254 static int
6255 slurp_ia64_unwind_table (FILE * file,
6256                          struct ia64_unw_aux_info * aux,
6257                          Elf_Internal_Shdr * sec)
6258 {
6259   unsigned long size, nrelas, i;
6260   Elf_Internal_Phdr * seg;
6261   struct ia64_unw_table_entry * tep;
6262   Elf_Internal_Shdr * relsec;
6263   Elf_Internal_Rela * rela;
6264   Elf_Internal_Rela * rp;
6265   unsigned char * table;
6266   unsigned char * tp;
6267   Elf_Internal_Sym * sym;
6268   const char * relname;
6269
6270   /* First, find the starting address of the segment that includes
6271      this section: */
6272
6273   if (elf_header.e_phnum)
6274     {
6275       if (! get_program_headers (file))
6276           return 0;
6277
6278       for (seg = program_headers;
6279            seg < program_headers + elf_header.e_phnum;
6280            ++seg)
6281         {
6282           if (seg->p_type != PT_LOAD)
6283             continue;
6284
6285           if (sec->sh_addr >= seg->p_vaddr
6286               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6287             {
6288               aux->seg_base = seg->p_vaddr;
6289               break;
6290             }
6291         }
6292     }
6293
6294   /* Second, build the unwind table from the contents of the unwind section:  */
6295   size = sec->sh_size;
6296   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6297                                       _("unwind table"));
6298   if (!table)
6299     return 0;
6300
6301   aux->table = (struct ia64_unw_table_entry *)
6302       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6303   tep = aux->table;
6304   for (tp = table; tp < table + size; ++tep)
6305     {
6306       tep->start.section = SHN_UNDEF;
6307       tep->end.section   = SHN_UNDEF;
6308       tep->info.section  = SHN_UNDEF;
6309       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6310       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6311       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6312       tep->start.offset += aux->seg_base;
6313       tep->end.offset   += aux->seg_base;
6314       tep->info.offset  += aux->seg_base;
6315     }
6316   free (table);
6317
6318   /* Third, apply any relocations to the unwind table:  */
6319   for (relsec = section_headers;
6320        relsec < section_headers + elf_header.e_shnum;
6321        ++relsec)
6322     {
6323       if (relsec->sh_type != SHT_RELA
6324           || relsec->sh_info >= elf_header.e_shnum
6325           || section_headers + relsec->sh_info != sec)
6326         continue;
6327
6328       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6329                               & rela, & nrelas))
6330         return 0;
6331
6332       for (rp = rela; rp < rela + nrelas; ++rp)
6333         {
6334           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6335           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6336
6337           if (! const_strneq (relname, "R_IA64_SEGREL"))
6338             {
6339               warn (_("Skipping unexpected relocation type %s\n"), relname);
6340               continue;
6341             }
6342
6343           i = rp->r_offset / (3 * eh_addr_size);
6344
6345           switch (rp->r_offset/eh_addr_size % 3)
6346             {
6347             case 0:
6348               aux->table[i].start.section = sym->st_shndx;
6349               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6350               break;
6351             case 1:
6352               aux->table[i].end.section   = sym->st_shndx;
6353               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6354               break;
6355             case 2:
6356               aux->table[i].info.section  = sym->st_shndx;
6357               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6358               break;
6359             default:
6360               break;
6361             }
6362         }
6363
6364       free (rela);
6365     }
6366
6367   aux->table_len = size / (3 * eh_addr_size);
6368   return 1;
6369 }
6370
6371 static void
6372 ia64_process_unwind (FILE * file)
6373 {
6374   Elf_Internal_Shdr * sec;
6375   Elf_Internal_Shdr * unwsec = NULL;
6376   Elf_Internal_Shdr * strsec;
6377   unsigned long i, unwcount = 0, unwstart = 0;
6378   struct ia64_unw_aux_info aux;
6379
6380   memset (& aux, 0, sizeof (aux));
6381
6382   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6383     {
6384       if (sec->sh_type == SHT_SYMTAB
6385           && sec->sh_link < elf_header.e_shnum)
6386         {
6387           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6388
6389           strsec = section_headers + sec->sh_link;
6390           assert (aux.strtab == NULL);
6391           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6392                                           1, strsec->sh_size,
6393                                           _("string table"));
6394           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6395         }
6396       else if (sec->sh_type == SHT_IA_64_UNWIND)
6397         unwcount++;
6398     }
6399
6400   if (!unwcount)
6401     printf (_("\nThere are no unwind sections in this file.\n"));
6402
6403   while (unwcount-- > 0)
6404     {
6405       char * suffix;
6406       size_t len, len2;
6407
6408       for (i = unwstart, sec = section_headers + unwstart;
6409            i < elf_header.e_shnum; ++i, ++sec)
6410         if (sec->sh_type == SHT_IA_64_UNWIND)
6411           {
6412             unwsec = sec;
6413             break;
6414           }
6415
6416       unwstart = i + 1;
6417       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6418
6419       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6420         {
6421           /* We need to find which section group it is in.  */
6422           struct group_list * g = section_headers_groups [i]->root;
6423
6424           for (; g != NULL; g = g->next)
6425             {
6426               sec = section_headers + g->section_index;
6427
6428               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6429                 break;
6430             }
6431
6432           if (g == NULL)
6433             i = elf_header.e_shnum;
6434         }
6435       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6436         {
6437           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6438           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6439           suffix = SECTION_NAME (unwsec) + len;
6440           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6441                ++i, ++sec)
6442             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6443                 && streq (SECTION_NAME (sec) + len2, suffix))
6444               break;
6445         }
6446       else
6447         {
6448           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6449              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6450           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6451           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6452           suffix = "";
6453           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6454             suffix = SECTION_NAME (unwsec) + len;
6455           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6456                ++i, ++sec)
6457             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6458                 && streq (SECTION_NAME (sec) + len2, suffix))
6459               break;
6460         }
6461
6462       if (i == elf_header.e_shnum)
6463         {
6464           printf (_("\nCould not find unwind info section for "));
6465
6466           if (string_table == NULL)
6467             printf ("%d", unwsec->sh_name);
6468           else
6469             printf (_("'%s'"), SECTION_NAME (unwsec));
6470         }
6471       else
6472         {
6473           aux.info_addr = sec->sh_addr;
6474           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6475                                                  sec->sh_size,
6476                                                  _("unwind info"));
6477           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6478
6479           printf (_("\nUnwind section "));
6480
6481           if (string_table == NULL)
6482             printf ("%d", unwsec->sh_name);
6483           else
6484             printf (_("'%s'"), SECTION_NAME (unwsec));
6485
6486           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6487                   (unsigned long) unwsec->sh_offset,
6488                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6489
6490           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6491
6492           if (aux.table_len > 0)
6493             dump_ia64_unwind (& aux);
6494
6495           if (aux.table)
6496             free ((char *) aux.table);
6497           if (aux.info)
6498             free ((char *) aux.info);
6499           aux.table = NULL;
6500           aux.info = NULL;
6501         }
6502     }
6503
6504   if (aux.symtab)
6505     free (aux.symtab);
6506   if (aux.strtab)
6507     free ((char *) aux.strtab);
6508 }
6509
6510 struct hppa_unw_table_entry
6511   {
6512     struct absaddr start;
6513     struct absaddr end;
6514     unsigned int Cannot_unwind:1;                       /* 0 */
6515     unsigned int Millicode:1;                   /* 1 */
6516     unsigned int Millicode_save_sr0:1;          /* 2 */
6517     unsigned int Region_description:2;          /* 3..4 */
6518     unsigned int reserved1:1;                   /* 5 */
6519     unsigned int Entry_SR:1;                    /* 6 */
6520     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6521     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6522     unsigned int Args_stored:1;                 /* 16 */
6523     unsigned int Variable_Frame:1;                      /* 17 */
6524     unsigned int Separate_Package_Body:1;               /* 18 */
6525     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6526     unsigned int Stack_Overflow_Check:1;                /* 20 */
6527     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6528     unsigned int Ada_Region:1;                  /* 22 */
6529     unsigned int cxx_info:1;                    /* 23 */
6530     unsigned int cxx_try_catch:1;                       /* 24 */
6531     unsigned int sched_entry_seq:1;                     /* 25 */
6532     unsigned int reserved2:1;                   /* 26 */
6533     unsigned int Save_SP:1;                             /* 27 */
6534     unsigned int Save_RP:1;                             /* 28 */
6535     unsigned int Save_MRP_in_frame:1;           /* 29 */
6536     unsigned int extn_ptr_defined:1;            /* 30 */
6537     unsigned int Cleanup_defined:1;                     /* 31 */
6538
6539     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6540     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6541     unsigned int Large_frame:1;                 /* 2 */
6542     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6543     unsigned int reserved4:1;                   /* 4 */
6544     unsigned int Total_frame_size:27;           /* 5..31 */
6545   };
6546
6547 struct hppa_unw_aux_info
6548   {
6549     struct hppa_unw_table_entry *table; /* Unwind table.  */
6550     unsigned long table_len;    /* Length of unwind table.  */
6551     bfd_vma seg_base;           /* Starting address of segment.  */
6552     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6553     unsigned long nsyms;        /* Number of symbols.  */
6554     char * strtab;              /* The string table.  */
6555     unsigned long strtab_size;  /* Size of string table.  */
6556   };
6557
6558 static void
6559 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6560 {
6561   struct hppa_unw_table_entry * tp;
6562
6563   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6564     {
6565       bfd_vma offset;
6566       const char * procname;
6567
6568       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6569                                aux->strtab_size, tp->start, &procname,
6570                                &offset);
6571
6572       fputs ("\n<", stdout);
6573
6574       if (procname)
6575         {
6576           fputs (procname, stdout);
6577
6578           if (offset)
6579             printf ("+%lx", (unsigned long) offset);
6580         }
6581
6582       fputs (">: [", stdout);
6583       print_vma (tp->start.offset, PREFIX_HEX);
6584       fputc ('-', stdout);
6585       print_vma (tp->end.offset, PREFIX_HEX);
6586       printf ("]\n\t");
6587
6588 #define PF(_m) if (tp->_m) printf (#_m " ");
6589 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6590       PF(Cannot_unwind);
6591       PF(Millicode);
6592       PF(Millicode_save_sr0);
6593       /* PV(Region_description);  */
6594       PF(Entry_SR);
6595       PV(Entry_FR);
6596       PV(Entry_GR);
6597       PF(Args_stored);
6598       PF(Variable_Frame);
6599       PF(Separate_Package_Body);
6600       PF(Frame_Extension_Millicode);
6601       PF(Stack_Overflow_Check);
6602       PF(Two_Instruction_SP_Increment);
6603       PF(Ada_Region);
6604       PF(cxx_info);
6605       PF(cxx_try_catch);
6606       PF(sched_entry_seq);
6607       PF(Save_SP);
6608       PF(Save_RP);
6609       PF(Save_MRP_in_frame);
6610       PF(extn_ptr_defined);
6611       PF(Cleanup_defined);
6612       PF(MPE_XL_interrupt_marker);
6613       PF(HP_UX_interrupt_marker);
6614       PF(Large_frame);
6615       PF(Pseudo_SP_Set);
6616       PV(Total_frame_size);
6617 #undef PF
6618 #undef PV
6619     }
6620
6621   printf ("\n");
6622 }
6623
6624 static int
6625 slurp_hppa_unwind_table (FILE * file,
6626                          struct hppa_unw_aux_info * aux,
6627                          Elf_Internal_Shdr * sec)
6628 {
6629   unsigned long size, unw_ent_size, nentries, nrelas, i;
6630   Elf_Internal_Phdr * seg;
6631   struct hppa_unw_table_entry * tep;
6632   Elf_Internal_Shdr * relsec;
6633   Elf_Internal_Rela * rela;
6634   Elf_Internal_Rela * rp;
6635   unsigned char * table;
6636   unsigned char * tp;
6637   Elf_Internal_Sym * sym;
6638   const char * relname;
6639
6640   /* First, find the starting address of the segment that includes
6641      this section.  */
6642
6643   if (elf_header.e_phnum)
6644     {
6645       if (! get_program_headers (file))
6646         return 0;
6647
6648       for (seg = program_headers;
6649            seg < program_headers + elf_header.e_phnum;
6650            ++seg)
6651         {
6652           if (seg->p_type != PT_LOAD)
6653             continue;
6654
6655           if (sec->sh_addr >= seg->p_vaddr
6656               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6657             {
6658               aux->seg_base = seg->p_vaddr;
6659               break;
6660             }
6661         }
6662     }
6663
6664   /* Second, build the unwind table from the contents of the unwind
6665      section.  */
6666   size = sec->sh_size;
6667   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6668                                       _("unwind table"));
6669   if (!table)
6670     return 0;
6671
6672   unw_ent_size = 16;
6673   nentries = size / unw_ent_size;
6674   size = unw_ent_size * nentries;
6675
6676   tep = aux->table = (struct hppa_unw_table_entry *)
6677       xcmalloc (nentries, sizeof (aux->table[0]));
6678
6679   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6680     {
6681       unsigned int tmp1, tmp2;
6682
6683       tep->start.section = SHN_UNDEF;
6684       tep->end.section   = SHN_UNDEF;
6685
6686       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6687       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6688       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6689       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6690
6691       tep->start.offset += aux->seg_base;
6692       tep->end.offset   += aux->seg_base;
6693
6694       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6695       tep->Millicode = (tmp1 >> 30) & 0x1;
6696       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6697       tep->Region_description = (tmp1 >> 27) & 0x3;
6698       tep->reserved1 = (tmp1 >> 26) & 0x1;
6699       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6700       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6701       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6702       tep->Args_stored = (tmp1 >> 15) & 0x1;
6703       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6704       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6705       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6706       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6707       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6708       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6709       tep->cxx_info = (tmp1 >> 8) & 0x1;
6710       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6711       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6712       tep->reserved2 = (tmp1 >> 5) & 0x1;
6713       tep->Save_SP = (tmp1 >> 4) & 0x1;
6714       tep->Save_RP = (tmp1 >> 3) & 0x1;
6715       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6716       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6717       tep->Cleanup_defined = tmp1 & 0x1;
6718
6719       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6720       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6721       tep->Large_frame = (tmp2 >> 29) & 0x1;
6722       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6723       tep->reserved4 = (tmp2 >> 27) & 0x1;
6724       tep->Total_frame_size = tmp2 & 0x7ffffff;
6725     }
6726   free (table);
6727
6728   /* Third, apply any relocations to the unwind table.  */
6729   for (relsec = section_headers;
6730        relsec < section_headers + elf_header.e_shnum;
6731        ++relsec)
6732     {
6733       if (relsec->sh_type != SHT_RELA
6734           || relsec->sh_info >= elf_header.e_shnum
6735           || section_headers + relsec->sh_info != sec)
6736         continue;
6737
6738       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6739                               & rela, & nrelas))
6740         return 0;
6741
6742       for (rp = rela; rp < rela + nrelas; ++rp)
6743         {
6744           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6745           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6746
6747           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6748           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6749             {
6750               warn (_("Skipping unexpected relocation type %s\n"), relname);
6751               continue;
6752             }
6753
6754           i = rp->r_offset / unw_ent_size;
6755
6756           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6757             {
6758             case 0:
6759               aux->table[i].start.section = sym->st_shndx;
6760               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6761               break;
6762             case 1:
6763               aux->table[i].end.section   = sym->st_shndx;
6764               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6765               break;
6766             default:
6767               break;
6768             }
6769         }
6770
6771       free (rela);
6772     }
6773
6774   aux->table_len = nentries;
6775
6776   return 1;
6777 }
6778
6779 static void
6780 hppa_process_unwind (FILE * file)
6781 {
6782   struct hppa_unw_aux_info aux;
6783   Elf_Internal_Shdr * unwsec = NULL;
6784   Elf_Internal_Shdr * strsec;
6785   Elf_Internal_Shdr * sec;
6786   unsigned long i;
6787
6788   if (string_table == NULL)
6789     return;
6790
6791   memset (& aux, 0, sizeof (aux));
6792
6793   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6794     {
6795       if (sec->sh_type == SHT_SYMTAB
6796           && sec->sh_link < elf_header.e_shnum)
6797         {
6798           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6799
6800           strsec = section_headers + sec->sh_link;
6801           assert (aux.strtab == NULL);
6802           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6803                                           1, strsec->sh_size,
6804                                           _("string table"));
6805           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6806         }
6807       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6808         unwsec = sec;
6809     }
6810
6811   if (!unwsec)
6812     printf (_("\nThere are no unwind sections in this file.\n"));
6813
6814   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6815     {
6816       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6817         {
6818           printf (_("\nUnwind section "));
6819           printf (_("'%s'"), SECTION_NAME (sec));
6820
6821           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6822                   (unsigned long) sec->sh_offset,
6823                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6824
6825           slurp_hppa_unwind_table (file, &aux, sec);
6826           if (aux.table_len > 0)
6827             dump_hppa_unwind (&aux);
6828
6829           if (aux.table)
6830             free ((char *) aux.table);
6831           aux.table = NULL;
6832         }
6833     }
6834
6835   if (aux.symtab)
6836     free (aux.symtab);
6837   if (aux.strtab)
6838     free ((char *) aux.strtab);
6839 }
6840
6841 struct arm_section
6842 {
6843   unsigned char *      data;            /* The unwind data.  */
6844   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6845   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6846   unsigned long        nrelas;          /* The number of relocations.  */
6847   unsigned int         rel_type;        /* REL or RELA ?  */
6848   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6849 };
6850
6851 struct arm_unw_aux_info
6852 {
6853   FILE *              file;             /* The file containing the unwind sections.  */
6854   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6855   unsigned long       nsyms;            /* Number of symbols.  */
6856   char *              strtab;           /* The file's string table.  */
6857   unsigned long       strtab_size;      /* Size of string table.  */
6858 };
6859
6860 static const char *
6861 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6862                         bfd_vma fn, struct absaddr addr)
6863 {
6864   const char *procname;
6865   bfd_vma sym_offset;
6866
6867   if (addr.section == SHN_UNDEF)
6868     addr.offset = fn;
6869
6870   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6871                            aux->strtab_size, addr, &procname,
6872                            &sym_offset);
6873
6874   print_vma (fn, PREFIX_HEX);
6875
6876   if (procname)
6877     {
6878       fputs (" <", stdout);
6879       fputs (procname, stdout);
6880
6881       if (sym_offset)
6882         printf ("+0x%lx", (unsigned long) sym_offset);
6883       fputc ('>', stdout);
6884     }
6885
6886   return procname;
6887 }
6888
6889 static void
6890 arm_free_section (struct arm_section *arm_sec)
6891 {
6892   if (arm_sec->data != NULL)
6893     free (arm_sec->data);
6894
6895   if (arm_sec->rela != NULL)
6896     free (arm_sec->rela);
6897 }
6898
6899 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6900       cached section and install SEC instead.
6901    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6902       and return its valued in * WORDP, relocating if necessary.
6903    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6904       relocation's offset in ADDR.
6905    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6906       into the string table of the symbol associated with the reloc.  If no
6907       reloc was applied store -1 there.
6908    5) Return TRUE upon success, FALSE otherwise.  */
6909
6910 static bfd_boolean
6911 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6912                          struct arm_section *       arm_sec,
6913                          Elf_Internal_Shdr *        sec,
6914                          bfd_vma                    word_offset,
6915                          unsigned int *             wordp,
6916                          struct absaddr *           addr,
6917                          bfd_vma *                  sym_name)
6918 {
6919   Elf_Internal_Rela *rp;
6920   Elf_Internal_Sym *sym;
6921   const char * relname;
6922   unsigned int word;
6923   bfd_boolean wrapped;
6924
6925   if (sec == NULL || arm_sec == NULL)
6926     return FALSE;
6927
6928   addr->section = SHN_UNDEF;
6929   addr->offset = 0;
6930
6931   if (sym_name != NULL)
6932     *sym_name = (bfd_vma) -1;
6933
6934   /* If necessary, update the section cache.  */
6935   if (sec != arm_sec->sec)
6936     {
6937       Elf_Internal_Shdr *relsec;
6938
6939       arm_free_section (arm_sec);
6940
6941       arm_sec->sec = sec;
6942       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6943                                 sec->sh_size, _("unwind data"));
6944       arm_sec->rela = NULL;
6945       arm_sec->nrelas = 0;
6946
6947       for (relsec = section_headers;
6948            relsec < section_headers + elf_header.e_shnum;
6949            ++relsec)
6950         {
6951           if (relsec->sh_info >= elf_header.e_shnum
6952               || section_headers + relsec->sh_info != sec
6953               /* PR 15745: Check the section type as well.  */
6954               || (relsec->sh_type != SHT_REL
6955                   && relsec->sh_type != SHT_RELA))
6956             continue;
6957
6958           arm_sec->rel_type = relsec->sh_type;
6959           if (relsec->sh_type == SHT_REL)
6960             {
6961               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6962                                      relsec->sh_size,
6963                                      & arm_sec->rela, & arm_sec->nrelas))
6964                 return FALSE;
6965             }
6966           else /* relsec->sh_type == SHT_RELA */
6967             {
6968               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6969                                       relsec->sh_size,
6970                                       & arm_sec->rela, & arm_sec->nrelas))
6971                 return FALSE;
6972             }
6973           break;
6974         }
6975
6976       arm_sec->next_rela = arm_sec->rela;
6977     }
6978
6979   /* If there is no unwind data we can do nothing.  */
6980   if (arm_sec->data == NULL)
6981     return FALSE;
6982
6983   /* If the offset is invalid then fail.  */
6984   if (word_offset > sec->sh_size - 4)
6985     return FALSE;
6986
6987   /* Get the word at the required offset.  */
6988   word = byte_get (arm_sec->data + word_offset, 4);
6989
6990   /* Look through the relocs to find the one that applies to the provided offset.  */
6991   wrapped = FALSE;
6992   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6993     {
6994       bfd_vma prelval, offset;
6995
6996       if (rp->r_offset > word_offset && !wrapped)
6997         {
6998           rp = arm_sec->rela;
6999           wrapped = TRUE;
7000         }
7001       if (rp->r_offset > word_offset)
7002         break;
7003
7004       if (rp->r_offset & 3)
7005         {
7006           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7007                 (unsigned long) rp->r_offset);
7008           continue;
7009         }
7010
7011       if (rp->r_offset < word_offset)
7012         continue;
7013
7014       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7015
7016       if (arm_sec->rel_type == SHT_REL)
7017         {
7018           offset = word & 0x7fffffff;
7019           if (offset & 0x40000000)
7020             offset |= ~ (bfd_vma) 0x7fffffff;
7021         }
7022       else if (arm_sec->rel_type == SHT_RELA)
7023         offset = rp->r_addend;
7024       else
7025         abort ();
7026
7027       offset += sym->st_value;
7028       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7029
7030       /* Check that we are processing the expected reloc type.  */
7031       if (elf_header.e_machine == EM_ARM)
7032         {
7033           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7034
7035           if (streq (relname, "R_ARM_NONE"))
7036               continue;
7037
7038           if (! streq (relname, "R_ARM_PREL31"))
7039             {
7040               warn (_("Skipping unexpected relocation type %s\n"), relname);
7041               continue;
7042             }
7043         }
7044       else if (elf_header.e_machine == EM_TI_C6000)
7045         {
7046           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7047
7048           if (streq (relname, "R_C6000_NONE"))
7049             continue;
7050
7051           if (! streq (relname, "R_C6000_PREL31"))
7052             {
7053               warn (_("Skipping unexpected relocation type %s\n"), relname);
7054               continue;
7055             }
7056
7057           prelval >>= 1;
7058         }
7059       else
7060         /* This function currently only supports ARM and TI unwinders.  */
7061         abort ();
7062
7063       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7064       addr->section = sym->st_shndx;
7065       addr->offset = offset;
7066       if (sym_name)
7067         * sym_name = sym->st_name;
7068       break;
7069     }
7070
7071   *wordp = word;
7072   arm_sec->next_rela = rp;
7073
7074   return TRUE;
7075 }
7076
7077 static const char *tic6x_unwind_regnames[16] =
7078 {
7079   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7080   "A14", "A13", "A12", "A11", "A10",
7081   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7082 };
7083
7084 static void
7085 decode_tic6x_unwind_regmask (unsigned int mask)
7086 {
7087   int i;
7088
7089   for (i = 12; mask; mask >>= 1, i--)
7090     {
7091       if (mask & 1)
7092         {
7093           fputs (tic6x_unwind_regnames[i], stdout);
7094           if (mask > 1)
7095             fputs (", ", stdout);
7096         }
7097     }
7098 }
7099
7100 #define ADVANCE                                                 \
7101   if (remaining == 0 && more_words)                             \
7102     {                                                           \
7103       data_offset += 4;                                         \
7104       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7105                                      data_offset, & word, & addr, NULL))        \
7106         return;                                                 \
7107       remaining = 4;                                            \
7108       more_words--;                                             \
7109     }                                                           \
7110
7111 #define GET_OP(OP)                      \
7112   ADVANCE;                              \
7113   if (remaining)                        \
7114     {                                   \
7115       remaining--;                      \
7116       (OP) = word >> 24;                \
7117       word <<= 8;                       \
7118     }                                   \
7119   else                                  \
7120     {                                   \
7121       printf (_("[Truncated opcode]\n"));       \
7122       return;                           \
7123     }                                   \
7124   printf ("0x%02x ", OP)
7125
7126 static void
7127 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7128                             unsigned int word, unsigned int remaining,
7129                             unsigned int more_words,
7130                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7131                             struct arm_section *data_arm_sec)
7132 {
7133   struct absaddr addr;
7134
7135   /* Decode the unwinding instructions.  */
7136   while (1)
7137     {
7138       unsigned int op, op2;
7139
7140       ADVANCE;
7141       if (remaining == 0)
7142         break;
7143       remaining--;
7144       op = word >> 24;
7145       word <<= 8;
7146
7147       printf ("  0x%02x ", op);
7148
7149       if ((op & 0xc0) == 0x00)
7150         {
7151           int offset = ((op & 0x3f) << 2) + 4;
7152
7153           printf ("     vsp = vsp + %d", offset);
7154         }
7155       else if ((op & 0xc0) == 0x40)
7156         {
7157           int offset = ((op & 0x3f) << 2) + 4;
7158
7159           printf ("     vsp = vsp - %d", offset);
7160         }
7161       else if ((op & 0xf0) == 0x80)
7162         {
7163           GET_OP (op2);
7164           if (op == 0x80 && op2 == 0)
7165             printf (_("Refuse to unwind"));
7166           else
7167             {
7168               unsigned int mask = ((op & 0x0f) << 8) | op2;
7169               int first = 1;
7170               int i;
7171
7172               printf ("pop {");
7173               for (i = 0; i < 12; i++)
7174                 if (mask & (1 << i))
7175                   {
7176                     if (first)
7177                       first = 0;
7178                     else
7179                       printf (", ");
7180                     printf ("r%d", 4 + i);
7181                   }
7182               printf ("}");
7183             }
7184         }
7185       else if ((op & 0xf0) == 0x90)
7186         {
7187           if (op == 0x9d || op == 0x9f)
7188             printf (_("     [Reserved]"));
7189           else
7190             printf ("     vsp = r%d", op & 0x0f);
7191         }
7192       else if ((op & 0xf0) == 0xa0)
7193         {
7194           int end = 4 + (op & 0x07);
7195           int first = 1;
7196           int i;
7197
7198           printf ("     pop {");
7199           for (i = 4; i <= end; i++)
7200             {
7201               if (first)
7202                 first = 0;
7203               else
7204                 printf (", ");
7205               printf ("r%d", i);
7206             }
7207           if (op & 0x08)
7208             {
7209               if (!first)
7210                 printf (", ");
7211               printf ("r14");
7212             }
7213           printf ("}");
7214         }
7215       else if (op == 0xb0)
7216         printf (_("     finish"));
7217       else if (op == 0xb1)
7218         {
7219           GET_OP (op2);
7220           if (op2 == 0 || (op2 & 0xf0) != 0)
7221             printf (_("[Spare]"));
7222           else
7223             {
7224               unsigned int mask = op2 & 0x0f;
7225               int first = 1;
7226               int i;
7227
7228               printf ("pop {");
7229               for (i = 0; i < 12; i++)
7230                 if (mask & (1 << i))
7231                   {
7232                     if (first)
7233                       first = 0;
7234                     else
7235                       printf (", ");
7236                     printf ("r%d", i);
7237                   }
7238               printf ("}");
7239             }
7240         }
7241       else if (op == 0xb2)
7242         {
7243           unsigned char buf[9];
7244           unsigned int i, len;
7245           unsigned long offset;
7246
7247           for (i = 0; i < sizeof (buf); i++)
7248             {
7249               GET_OP (buf[i]);
7250               if ((buf[i] & 0x80) == 0)
7251                 break;
7252             }
7253           assert (i < sizeof (buf));
7254           offset = read_uleb128 (buf, &len, buf + i + 1);
7255           assert (len == i + 1);
7256           offset = offset * 4 + 0x204;
7257           printf ("vsp = vsp + %ld", offset);
7258         }
7259       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7260         {
7261           unsigned int first, last;
7262
7263           GET_OP (op2);
7264           first = op2 >> 4;
7265           last = op2 & 0x0f;
7266           if (op == 0xc8)
7267             first = first + 16;
7268           printf ("pop {D%d", first);
7269           if (last)
7270             printf ("-D%d", first + last);
7271           printf ("}");
7272         }
7273       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7274         {
7275           unsigned int count = op & 0x07;
7276
7277           printf ("pop {D8");
7278           if (count)
7279             printf ("-D%d", 8 + count);
7280           printf ("}");
7281         }
7282       else if (op >= 0xc0 && op <= 0xc5)
7283         {
7284           unsigned int count = op & 0x07;
7285
7286           printf ("     pop {wR10");
7287           if (count)
7288             printf ("-wR%d", 10 + count);
7289           printf ("}");
7290         }
7291       else if (op == 0xc6)
7292         {
7293           unsigned int first, last;
7294
7295           GET_OP (op2);
7296           first = op2 >> 4;
7297           last = op2 & 0x0f;
7298           printf ("pop {wR%d", first);
7299           if (last)
7300             printf ("-wR%d", first + last);
7301           printf ("}");
7302         }
7303       else if (op == 0xc7)
7304         {
7305           GET_OP (op2);
7306           if (op2 == 0 || (op2 & 0xf0) != 0)
7307             printf (_("[Spare]"));
7308           else
7309             {
7310               unsigned int mask = op2 & 0x0f;
7311               int first = 1;
7312               int i;
7313
7314               printf ("pop {");
7315               for (i = 0; i < 4; i++)
7316                 if (mask & (1 << i))
7317                   {
7318                     if (first)
7319                       first = 0;
7320                     else
7321                       printf (", ");
7322                     printf ("wCGR%d", i);
7323                   }
7324               printf ("}");
7325             }
7326         }
7327       else
7328         printf (_("     [unsupported opcode]"));
7329       printf ("\n");
7330     }
7331 }
7332
7333 static void
7334 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7335                             unsigned int word, unsigned int remaining,
7336                             unsigned int more_words,
7337                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7338                             struct arm_section *data_arm_sec)
7339 {
7340   struct absaddr addr;
7341
7342   /* Decode the unwinding instructions.  */
7343   while (1)
7344     {
7345       unsigned int op, op2;
7346
7347       ADVANCE;
7348       if (remaining == 0)
7349         break;
7350       remaining--;
7351       op = word >> 24;
7352       word <<= 8;
7353
7354       printf ("  0x%02x ", op);
7355
7356       if ((op & 0xc0) == 0x00)
7357         {
7358           int offset = ((op & 0x3f) << 3) + 8;
7359           printf ("     sp = sp + %d", offset);
7360         }
7361       else if ((op & 0xc0) == 0x80)
7362         {
7363           GET_OP (op2);
7364           if (op == 0x80 && op2 == 0)
7365             printf (_("Refuse to unwind"));
7366           else
7367             {
7368               unsigned int mask = ((op & 0x1f) << 8) | op2;
7369               if (op & 0x20)
7370                 printf ("pop compact {");
7371               else
7372                 printf ("pop {");
7373
7374               decode_tic6x_unwind_regmask (mask);
7375               printf("}");
7376             }
7377         }
7378       else if ((op & 0xf0) == 0xc0)
7379         {
7380           unsigned int reg;
7381           unsigned int nregs;
7382           unsigned int i;
7383           const char *name;
7384           struct
7385           {
7386               unsigned int offset;
7387               unsigned int reg;
7388           } regpos[16];
7389
7390           /* Scan entire instruction first so that GET_OP output is not
7391              interleaved with disassembly.  */
7392           nregs = 0;
7393           for (i = 0; nregs < (op & 0xf); i++)
7394             {
7395               GET_OP (op2);
7396               reg = op2 >> 4;
7397               if (reg != 0xf)
7398                 {
7399                   regpos[nregs].offset = i * 2;
7400                   regpos[nregs].reg = reg;
7401                   nregs++;
7402                 }
7403
7404               reg = op2 & 0xf;
7405               if (reg != 0xf)
7406                 {
7407                   regpos[nregs].offset = i * 2 + 1;
7408                   regpos[nregs].reg = reg;
7409                   nregs++;
7410                 }
7411             }
7412
7413           printf (_("pop frame {"));
7414           reg = nregs - 1;
7415           for (i = i * 2; i > 0; i--)
7416             {
7417               if (regpos[reg].offset == i - 1)
7418                 {
7419                   name = tic6x_unwind_regnames[regpos[reg].reg];
7420                   if (reg > 0)
7421                     reg--;
7422                 }
7423               else
7424                 name = _("[pad]");
7425
7426               fputs (name, stdout);
7427               if (i > 1)
7428                 printf (", ");
7429             }
7430
7431           printf ("}");
7432         }
7433       else if (op == 0xd0)
7434         printf ("     MOV FP, SP");
7435       else if (op == 0xd1)
7436         printf ("     __c6xabi_pop_rts");
7437       else if (op == 0xd2)
7438         {
7439           unsigned char buf[9];
7440           unsigned int i, len;
7441           unsigned long offset;
7442
7443           for (i = 0; i < sizeof (buf); i++)
7444             {
7445               GET_OP (buf[i]);
7446               if ((buf[i] & 0x80) == 0)
7447                 break;
7448             }
7449           assert (i < sizeof (buf));
7450           offset = read_uleb128 (buf, &len, buf + i + 1);
7451           assert (len == i + 1);
7452           offset = offset * 8 + 0x408;
7453           printf (_("sp = sp + %ld"), offset);
7454         }
7455       else if ((op & 0xf0) == 0xe0)
7456         {
7457           if ((op & 0x0f) == 7)
7458             printf ("     RETURN");
7459           else
7460             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7461         }
7462       else
7463         {
7464           printf (_("     [unsupported opcode]"));
7465         }
7466       putchar ('\n');
7467     }
7468 }
7469
7470 static bfd_vma
7471 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7472 {
7473   bfd_vma offset;
7474
7475   offset = word & 0x7fffffff;
7476   if (offset & 0x40000000)
7477     offset |= ~ (bfd_vma) 0x7fffffff;
7478
7479   if (elf_header.e_machine == EM_TI_C6000)
7480     offset <<= 1;
7481
7482   return offset + where;
7483 }
7484
7485 static void
7486 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7487                    unsigned int               word,
7488                    unsigned int               remaining,
7489                    bfd_vma                    data_offset,
7490                    Elf_Internal_Shdr *        data_sec,
7491                    struct arm_section *       data_arm_sec)
7492 {
7493   int per_index;
7494   unsigned int more_words = 0;
7495   struct absaddr addr;
7496   bfd_vma sym_name = (bfd_vma) -1;
7497
7498   if (remaining == 0)
7499     {
7500       /* Fetch the first word.
7501          Note - when decoding an object file the address extracted
7502          here will always be 0.  So we also pass in the sym_name
7503          parameter so that we can find the symbol associated with
7504          the personality routine.  */
7505       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7506                                      & word, & addr, & sym_name))
7507         return;
7508
7509       remaining = 4;
7510     }
7511
7512   if ((word & 0x80000000) == 0)
7513     {
7514       /* Expand prel31 for personality routine.  */
7515       bfd_vma fn;
7516       const char *procname;
7517
7518       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7519       printf (_("  Personality routine: "));
7520       if (fn == 0
7521           && addr.section == SHN_UNDEF && addr.offset == 0
7522           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7523         {
7524           procname = aux->strtab + sym_name;
7525           print_vma (fn, PREFIX_HEX);
7526           if (procname)
7527             {
7528               fputs (" <", stdout);
7529               fputs (procname, stdout);
7530               fputc ('>', stdout);
7531             }
7532         }
7533       else
7534         procname = arm_print_vma_and_name (aux, fn, addr);
7535       fputc ('\n', stdout);
7536
7537       /* The GCC personality routines use the standard compact
7538          encoding, starting with one byte giving the number of
7539          words.  */
7540       if (procname != NULL
7541           && (const_strneq (procname, "__gcc_personality_v0")
7542               || const_strneq (procname, "__gxx_personality_v0")
7543               || const_strneq (procname, "__gcj_personality_v0")
7544               || const_strneq (procname, "__gnu_objc_personality_v0")))
7545         {
7546           remaining = 0;
7547           more_words = 1;
7548           ADVANCE;
7549           if (!remaining)
7550             {
7551               printf (_("  [Truncated data]\n"));
7552               return;
7553             }
7554           more_words = word >> 24;
7555           word <<= 8;
7556           remaining--;
7557           per_index = -1;
7558         }
7559       else
7560         return;
7561     }
7562   else
7563     {
7564       /* ARM EHABI Section 6.3:
7565
7566          An exception-handling table entry for the compact model looks like:
7567
7568            31 30-28 27-24 23-0
7569            -- ----- ----- ----
7570             1   0   index Data for personalityRoutine[index]    */
7571
7572       if (elf_header.e_machine == EM_ARM
7573           && (word & 0x70000000))
7574         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7575
7576       per_index = (word >> 24) & 0x7f;
7577       printf (_("  Compact model index: %d\n"), per_index);
7578       if (per_index == 0)
7579         {
7580           more_words = 0;
7581           word <<= 8;
7582           remaining--;
7583         }
7584       else if (per_index < 3)
7585         {
7586           more_words = (word >> 16) & 0xff;
7587           word <<= 16;
7588           remaining -= 2;
7589         }
7590     }
7591
7592   switch (elf_header.e_machine)
7593     {
7594     case EM_ARM:
7595       if (per_index < 3)
7596         {
7597           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7598                                       data_offset, data_sec, data_arm_sec);
7599         }
7600       else
7601         {
7602           warn (_("Unknown ARM compact model index encountered\n"));
7603           printf (_("  [reserved]\n"));
7604         }
7605       break;
7606
7607     case EM_TI_C6000:
7608       if (per_index < 3)
7609         {
7610           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7611                                         data_offset, data_sec, data_arm_sec);
7612         }
7613       else if (per_index < 5)
7614         {
7615           if (((word >> 17) & 0x7f) == 0x7f)
7616             printf (_("  Restore stack from frame pointer\n"));
7617           else
7618             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7619           printf (_("  Registers restored: "));
7620           if (per_index == 4)
7621             printf (" (compact) ");
7622           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7623           putchar ('\n');
7624           printf (_("  Return register: %s\n"),
7625                   tic6x_unwind_regnames[word & 0xf]);
7626         }
7627       else
7628         printf (_("  [reserved (%d)]\n"), per_index);
7629       break;
7630
7631     default:
7632       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7633              elf_header.e_machine);
7634     }
7635
7636   /* Decode the descriptors.  Not implemented.  */
7637 }
7638
7639 static void
7640 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7641 {
7642   struct arm_section exidx_arm_sec, extab_arm_sec;
7643   unsigned int i, exidx_len;
7644
7645   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7646   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7647   exidx_len = exidx_sec->sh_size / 8;
7648
7649   for (i = 0; i < exidx_len; i++)
7650     {
7651       unsigned int exidx_fn, exidx_entry;
7652       struct absaddr fn_addr, entry_addr;
7653       bfd_vma fn;
7654
7655       fputc ('\n', stdout);
7656
7657       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7658                                      8 * i, & exidx_fn, & fn_addr, NULL)
7659           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7660                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7661         {
7662           arm_free_section (& exidx_arm_sec);
7663           arm_free_section (& extab_arm_sec);
7664           return;
7665         }
7666
7667       /* ARM EHABI, Section 5:
7668          An index table entry consists of 2 words.
7669          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7670       if (exidx_fn & 0x80000000)
7671         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7672
7673       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7674
7675       arm_print_vma_and_name (aux, fn, fn_addr);
7676       fputs (": ", stdout);
7677
7678       if (exidx_entry == 1)
7679         {
7680           print_vma (exidx_entry, PREFIX_HEX);
7681           fputs (" [cantunwind]\n", stdout);
7682         }
7683       else if (exidx_entry & 0x80000000)
7684         {
7685           print_vma (exidx_entry, PREFIX_HEX);
7686           fputc ('\n', stdout);
7687           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7688         }
7689       else
7690         {
7691           bfd_vma table, table_offset = 0;
7692           Elf_Internal_Shdr *table_sec;
7693
7694           fputs ("@", stdout);
7695           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7696           print_vma (table, PREFIX_HEX);
7697           printf ("\n");
7698
7699           /* Locate the matching .ARM.extab.  */
7700           if (entry_addr.section != SHN_UNDEF
7701               && entry_addr.section < elf_header.e_shnum)
7702             {
7703               table_sec = section_headers + entry_addr.section;
7704               table_offset = entry_addr.offset;
7705             }
7706           else
7707             {
7708               table_sec = find_section_by_address (table);
7709               if (table_sec != NULL)
7710                 table_offset = table - table_sec->sh_addr;
7711             }
7712           if (table_sec == NULL)
7713             {
7714               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7715                     (unsigned long) table);
7716               continue;
7717             }
7718           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7719                              &extab_arm_sec);
7720         }
7721     }
7722
7723   printf ("\n");
7724
7725   arm_free_section (&exidx_arm_sec);
7726   arm_free_section (&extab_arm_sec);
7727 }
7728
7729 /* Used for both ARM and C6X unwinding tables.  */
7730
7731 static void
7732 arm_process_unwind (FILE *file)
7733 {
7734   struct arm_unw_aux_info aux;
7735   Elf_Internal_Shdr *unwsec = NULL;
7736   Elf_Internal_Shdr *strsec;
7737   Elf_Internal_Shdr *sec;
7738   unsigned long i;
7739   unsigned int sec_type;
7740
7741   switch (elf_header.e_machine)
7742     {
7743     case EM_ARM:
7744       sec_type = SHT_ARM_EXIDX;
7745       break;
7746
7747     case EM_TI_C6000:
7748       sec_type = SHT_C6000_UNWIND;
7749       break;
7750
7751     default:
7752       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7753              elf_header.e_machine);
7754       return;
7755     }
7756
7757   if (string_table == NULL)
7758     return;
7759
7760   memset (& aux, 0, sizeof (aux));
7761   aux.file = file;
7762
7763   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7764     {
7765       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7766         {
7767           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7768
7769           strsec = section_headers + sec->sh_link;
7770           assert (aux.strtab == NULL);
7771           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7772                                  1, strsec->sh_size, _("string table"));
7773           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7774         }
7775       else if (sec->sh_type == sec_type)
7776         unwsec = sec;
7777     }
7778
7779   if (unwsec == NULL)
7780     printf (_("\nThere are no unwind sections in this file.\n"));
7781   else
7782     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7783       {
7784         if (sec->sh_type == sec_type)
7785           {
7786             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7787                     SECTION_NAME (sec),
7788                     (unsigned long) sec->sh_offset,
7789                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7790
7791             dump_arm_unwind (&aux, sec);
7792           }
7793       }
7794
7795   if (aux.symtab)
7796     free (aux.symtab);
7797   if (aux.strtab)
7798     free ((char *) aux.strtab);
7799 }
7800
7801 static void
7802 process_unwind (FILE * file)
7803 {
7804   struct unwind_handler
7805   {
7806     int machtype;
7807     void (* handler)(FILE *);
7808   } handlers[] =
7809   {
7810     { EM_ARM, arm_process_unwind },
7811     { EM_IA_64, ia64_process_unwind },
7812     { EM_PARISC, hppa_process_unwind },
7813     { EM_TI_C6000, arm_process_unwind },
7814     { 0, 0 }
7815   };
7816   int i;
7817
7818   if (!do_unwind)
7819     return;
7820
7821   for (i = 0; handlers[i].handler != NULL; i++)
7822     if (elf_header.e_machine == handlers[i].machtype)
7823       {
7824         handlers[i].handler (file);
7825         return;
7826       }
7827
7828   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7829           get_machine_name (elf_header.e_machine));
7830 }
7831
7832 static void
7833 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7834 {
7835   switch (entry->d_tag)
7836     {
7837     case DT_MIPS_FLAGS:
7838       if (entry->d_un.d_val == 0)
7839         printf (_("NONE"));
7840       else
7841         {
7842           static const char * opts[] =
7843           {
7844             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7845             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7846             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7847             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7848             "RLD_ORDER_SAFE"
7849           };
7850           unsigned int cnt;
7851           int first = 1;
7852
7853           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7854             if (entry->d_un.d_val & (1 << cnt))
7855               {
7856                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7857                 first = 0;
7858               }
7859         }
7860       break;
7861
7862     case DT_MIPS_IVERSION:
7863       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7864         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7865       else
7866         {
7867           char buf[40];
7868           sprintf_vma (buf, entry->d_un.d_ptr);
7869           /* Note: coded this way so that there is a single string for translation.  */
7870           printf (_("<corrupt: %s>"), buf);
7871         }
7872       break;
7873
7874     case DT_MIPS_TIME_STAMP:
7875       {
7876         char timebuf[20];
7877         struct tm * tmp;
7878
7879         time_t atime = entry->d_un.d_val;
7880         tmp = gmtime (&atime);
7881         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7882                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7883                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7884         printf (_("Time Stamp: %s"), timebuf);
7885       }
7886       break;
7887
7888     case DT_MIPS_RLD_VERSION:
7889     case DT_MIPS_LOCAL_GOTNO:
7890     case DT_MIPS_CONFLICTNO:
7891     case DT_MIPS_LIBLISTNO:
7892     case DT_MIPS_SYMTABNO:
7893     case DT_MIPS_UNREFEXTNO:
7894     case DT_MIPS_HIPAGENO:
7895     case DT_MIPS_DELTA_CLASS_NO:
7896     case DT_MIPS_DELTA_INSTANCE_NO:
7897     case DT_MIPS_DELTA_RELOC_NO:
7898     case DT_MIPS_DELTA_SYM_NO:
7899     case DT_MIPS_DELTA_CLASSSYM_NO:
7900     case DT_MIPS_COMPACT_SIZE:
7901       print_vma (entry->d_un.d_ptr, DEC);
7902       break;
7903
7904     default:
7905       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7906     }
7907     putchar ('\n');
7908 }
7909
7910 static void
7911 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7912 {
7913   switch (entry->d_tag)
7914     {
7915     case DT_HP_DLD_FLAGS:
7916       {
7917         static struct
7918         {
7919           long int bit;
7920           const char * str;
7921         }
7922         flags[] =
7923         {
7924           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7925           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7926           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7927           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7928           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7929           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7930           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7931           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7932           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7933           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7934           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7935           { DT_HP_GST, "HP_GST" },
7936           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7937           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7938           { DT_HP_NODELETE, "HP_NODELETE" },
7939           { DT_HP_GROUP, "HP_GROUP" },
7940           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7941         };
7942         int first = 1;
7943         size_t cnt;
7944         bfd_vma val = entry->d_un.d_val;
7945
7946         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7947           if (val & flags[cnt].bit)
7948             {
7949               if (! first)
7950                 putchar (' ');
7951               fputs (flags[cnt].str, stdout);
7952               first = 0;
7953               val ^= flags[cnt].bit;
7954             }
7955
7956         if (val != 0 || first)
7957           {
7958             if (! first)
7959               putchar (' ');
7960             print_vma (val, HEX);
7961           }
7962       }
7963       break;
7964
7965     default:
7966       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7967       break;
7968     }
7969   putchar ('\n');
7970 }
7971
7972 #ifdef BFD64
7973
7974 /* VMS vs Unix time offset and factor.  */
7975
7976 #define VMS_EPOCH_OFFSET 35067168000000000LL
7977 #define VMS_GRANULARITY_FACTOR 10000000
7978
7979 /* Display a VMS time in a human readable format.  */
7980
7981 static void
7982 print_vms_time (bfd_int64_t vmstime)
7983 {
7984   struct tm *tm;
7985   time_t unxtime;
7986
7987   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7988   tm = gmtime (&unxtime);
7989   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7990           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7991           tm->tm_hour, tm->tm_min, tm->tm_sec);
7992 }
7993 #endif /* BFD64 */
7994
7995 static void
7996 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7997 {
7998   switch (entry->d_tag)
7999     {
8000     case DT_IA_64_PLT_RESERVE:
8001       /* First 3 slots reserved.  */
8002       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8003       printf (" -- ");
8004       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8005       break;
8006
8007     case DT_IA_64_VMS_LINKTIME:
8008 #ifdef BFD64
8009       print_vms_time (entry->d_un.d_val);
8010 #endif
8011       break;
8012
8013     case DT_IA_64_VMS_LNKFLAGS:
8014       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8015       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8016         printf (" CALL_DEBUG");
8017       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8018         printf (" NOP0BUFS");
8019       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8020         printf (" P0IMAGE");
8021       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8022         printf (" MKTHREADS");
8023       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8024         printf (" UPCALLS");
8025       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8026         printf (" IMGSTA");
8027       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8028         printf (" INITIALIZE");
8029       if (entry->d_un.d_val & VMS_LF_MAIN)
8030         printf (" MAIN");
8031       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8032         printf (" EXE_INIT");
8033       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8034         printf (" TBK_IN_IMG");
8035       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8036         printf (" DBG_IN_IMG");
8037       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8038         printf (" TBK_IN_DSF");
8039       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8040         printf (" DBG_IN_DSF");
8041       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8042         printf (" SIGNATURES");
8043       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8044         printf (" REL_SEG_OFF");
8045       break;
8046
8047     default:
8048       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8049       break;
8050     }
8051   putchar ('\n');
8052 }
8053
8054 static int
8055 get_32bit_dynamic_section (FILE * file)
8056 {
8057   Elf32_External_Dyn * edyn;
8058   Elf32_External_Dyn * ext;
8059   Elf_Internal_Dyn * entry;
8060
8061   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8062                                           dynamic_size, _("dynamic section"));
8063   if (!edyn)
8064     return 0;
8065
8066 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8067    might not have the luxury of section headers.  Look for the DT_NULL
8068    terminator to determine the number of entries.  */
8069   for (ext = edyn, dynamic_nent = 0;
8070        (char *) ext < (char *) edyn + dynamic_size;
8071        ext++)
8072     {
8073       dynamic_nent++;
8074       if (BYTE_GET (ext->d_tag) == DT_NULL)
8075         break;
8076     }
8077
8078   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8079                                                   sizeof (* entry));
8080   if (dynamic_section == NULL)
8081     {
8082       error (_("Out of memory\n"));
8083       free (edyn);
8084       return 0;
8085     }
8086
8087   for (ext = edyn, entry = dynamic_section;
8088        entry < dynamic_section + dynamic_nent;
8089        ext++, entry++)
8090     {
8091       entry->d_tag      = BYTE_GET (ext->d_tag);
8092       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8093     }
8094
8095   free (edyn);
8096
8097   return 1;
8098 }
8099
8100 static int
8101 get_64bit_dynamic_section (FILE * file)
8102 {
8103   Elf64_External_Dyn * edyn;
8104   Elf64_External_Dyn * ext;
8105   Elf_Internal_Dyn * entry;
8106
8107   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8108                                           dynamic_size, _("dynamic section"));
8109   if (!edyn)
8110     return 0;
8111
8112 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8113    might not have the luxury of section headers.  Look for the DT_NULL
8114    terminator to determine the number of entries.  */
8115   for (ext = edyn, dynamic_nent = 0;
8116        (char *) ext < (char *) edyn + dynamic_size;
8117        ext++)
8118     {
8119       dynamic_nent++;
8120       if (BYTE_GET (ext->d_tag) == DT_NULL)
8121         break;
8122     }
8123
8124   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8125                                                   sizeof (* entry));
8126   if (dynamic_section == NULL)
8127     {
8128       error (_("Out of memory\n"));
8129       free (edyn);
8130       return 0;
8131     }
8132
8133   for (ext = edyn, entry = dynamic_section;
8134        entry < dynamic_section + dynamic_nent;
8135        ext++, entry++)
8136     {
8137       entry->d_tag      = BYTE_GET (ext->d_tag);
8138       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8139     }
8140
8141   free (edyn);
8142
8143   return 1;
8144 }
8145
8146 static void
8147 print_dynamic_flags (bfd_vma flags)
8148 {
8149   int first = 1;
8150
8151   while (flags)
8152     {
8153       bfd_vma flag;
8154
8155       flag = flags & - flags;
8156       flags &= ~ flag;
8157
8158       if (first)
8159         first = 0;
8160       else
8161         putc (' ', stdout);
8162
8163       switch (flag)
8164         {
8165         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8166         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8167         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8168         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8169         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8170         default:                fputs (_("unknown"), stdout); break;
8171         }
8172     }
8173   puts ("");
8174 }
8175
8176 /* Parse and display the contents of the dynamic section.  */
8177
8178 static int
8179 process_dynamic_section (FILE * file)
8180 {
8181   Elf_Internal_Dyn * entry;
8182
8183   if (dynamic_size == 0)
8184     {
8185       if (do_dynamic)
8186         printf (_("\nThere is no dynamic section in this file.\n"));
8187
8188       return 1;
8189     }
8190
8191   if (is_32bit_elf)
8192     {
8193       if (! get_32bit_dynamic_section (file))
8194         return 0;
8195     }
8196   else if (! get_64bit_dynamic_section (file))
8197     return 0;
8198
8199   /* Find the appropriate symbol table.  */
8200   if (dynamic_symbols == NULL)
8201     {
8202       for (entry = dynamic_section;
8203            entry < dynamic_section + dynamic_nent;
8204            ++entry)
8205         {
8206           Elf_Internal_Shdr section;
8207
8208           if (entry->d_tag != DT_SYMTAB)
8209             continue;
8210
8211           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8212
8213           /* Since we do not know how big the symbol table is,
8214              we default to reading in the entire file (!) and
8215              processing that.  This is overkill, I know, but it
8216              should work.  */
8217           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8218
8219           if (archive_file_offset != 0)
8220             section.sh_size = archive_file_size - section.sh_offset;
8221           else
8222             {
8223               if (fseek (file, 0, SEEK_END))
8224                 error (_("Unable to seek to end of file!\n"));
8225
8226               section.sh_size = ftell (file) - section.sh_offset;
8227             }
8228
8229           if (is_32bit_elf)
8230             section.sh_entsize = sizeof (Elf32_External_Sym);
8231           else
8232             section.sh_entsize = sizeof (Elf64_External_Sym);
8233
8234           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8235           if (num_dynamic_syms < 1)
8236             {
8237               error (_("Unable to determine the number of symbols to load\n"));
8238               continue;
8239             }
8240         }
8241     }
8242
8243   /* Similarly find a string table.  */
8244   if (dynamic_strings == NULL)
8245     {
8246       for (entry = dynamic_section;
8247            entry < dynamic_section + dynamic_nent;
8248            ++entry)
8249         {
8250           unsigned long offset;
8251           long str_tab_len;
8252
8253           if (entry->d_tag != DT_STRTAB)
8254             continue;
8255
8256           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8257
8258           /* Since we do not know how big the string table is,
8259              we default to reading in the entire file (!) and
8260              processing that.  This is overkill, I know, but it
8261              should work.  */
8262
8263           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8264
8265           if (archive_file_offset != 0)
8266             str_tab_len = archive_file_size - offset;
8267           else
8268             {
8269               if (fseek (file, 0, SEEK_END))
8270                 error (_("Unable to seek to end of file\n"));
8271               str_tab_len = ftell (file) - offset;
8272             }
8273
8274           if (str_tab_len < 1)
8275             {
8276               error
8277                 (_("Unable to determine the length of the dynamic string table\n"));
8278               continue;
8279             }
8280
8281           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8282                                                str_tab_len,
8283                                                _("dynamic string table"));
8284           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8285           break;
8286         }
8287     }
8288
8289   /* And find the syminfo section if available.  */
8290   if (dynamic_syminfo == NULL)
8291     {
8292       unsigned long syminsz = 0;
8293
8294       for (entry = dynamic_section;
8295            entry < dynamic_section + dynamic_nent;
8296            ++entry)
8297         {
8298           if (entry->d_tag == DT_SYMINENT)
8299             {
8300               /* Note: these braces are necessary to avoid a syntax
8301                  error from the SunOS4 C compiler.  */
8302               /* PR binutils/17531: A corrupt file can trigger this test.
8303                  So do not use an assert, instead generate an error message.  */
8304               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8305                 error (_("Bad value (%d) for SYMINENT entry"),
8306                        (int) entry->d_un.d_val);
8307             }
8308           else if (entry->d_tag == DT_SYMINSZ)
8309             syminsz = entry->d_un.d_val;
8310           else if (entry->d_tag == DT_SYMINFO)
8311             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8312                                                       syminsz);
8313         }
8314
8315       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8316         {
8317           Elf_External_Syminfo * extsyminfo;
8318           Elf_External_Syminfo * extsym;
8319           Elf_Internal_Syminfo * syminfo;
8320
8321           /* There is a syminfo section.  Read the data.  */
8322           extsyminfo = (Elf_External_Syminfo *)
8323               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8324                         _("symbol information"));
8325           if (!extsyminfo)
8326             return 0;
8327
8328           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8329           if (dynamic_syminfo == NULL)
8330             {
8331               error (_("Out of memory\n"));
8332               return 0;
8333             }
8334
8335           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8336           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8337                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8338                ++syminfo, ++extsym)
8339             {
8340               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8341               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8342             }
8343
8344           free (extsyminfo);
8345         }
8346     }
8347
8348   if (do_dynamic && dynamic_addr)
8349     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8350             dynamic_addr, dynamic_nent);
8351   if (do_dynamic)
8352     printf (_("  Tag        Type                         Name/Value\n"));
8353
8354   for (entry = dynamic_section;
8355        entry < dynamic_section + dynamic_nent;
8356        entry++)
8357     {
8358       if (do_dynamic)
8359         {
8360           const char * dtype;
8361
8362           putchar (' ');
8363           print_vma (entry->d_tag, FULL_HEX);
8364           dtype = get_dynamic_type (entry->d_tag);
8365           printf (" (%s)%*s", dtype,
8366                   ((is_32bit_elf ? 27 : 19)
8367                    - (int) strlen (dtype)),
8368                   " ");
8369         }
8370
8371       switch (entry->d_tag)
8372         {
8373         case DT_FLAGS:
8374           if (do_dynamic)
8375             print_dynamic_flags (entry->d_un.d_val);
8376           break;
8377
8378         case DT_AUXILIARY:
8379         case DT_FILTER:
8380         case DT_CONFIG:
8381         case DT_DEPAUDIT:
8382         case DT_AUDIT:
8383           if (do_dynamic)
8384             {
8385               switch (entry->d_tag)
8386                 {
8387                 case DT_AUXILIARY:
8388                   printf (_("Auxiliary library"));
8389                   break;
8390
8391                 case DT_FILTER:
8392                   printf (_("Filter library"));
8393                   break;
8394
8395                 case DT_CONFIG:
8396                   printf (_("Configuration file"));
8397                   break;
8398
8399                 case DT_DEPAUDIT:
8400                   printf (_("Dependency audit library"));
8401                   break;
8402
8403                 case DT_AUDIT:
8404                   printf (_("Audit library"));
8405                   break;
8406                 }
8407
8408               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8409                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8410               else
8411                 {
8412                   printf (": ");
8413                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8414                   putchar ('\n');
8415                 }
8416             }
8417           break;
8418
8419         case DT_FEATURE:
8420           if (do_dynamic)
8421             {
8422               printf (_("Flags:"));
8423
8424               if (entry->d_un.d_val == 0)
8425                 printf (_(" None\n"));
8426               else
8427                 {
8428                   unsigned long int val = entry->d_un.d_val;
8429
8430                   if (val & DTF_1_PARINIT)
8431                     {
8432                       printf (" PARINIT");
8433                       val ^= DTF_1_PARINIT;
8434                     }
8435                   if (val & DTF_1_CONFEXP)
8436                     {
8437                       printf (" CONFEXP");
8438                       val ^= DTF_1_CONFEXP;
8439                     }
8440                   if (val != 0)
8441                     printf (" %lx", val);
8442                   puts ("");
8443                 }
8444             }
8445           break;
8446
8447         case DT_POSFLAG_1:
8448           if (do_dynamic)
8449             {
8450               printf (_("Flags:"));
8451
8452               if (entry->d_un.d_val == 0)
8453                 printf (_(" None\n"));
8454               else
8455                 {
8456                   unsigned long int val = entry->d_un.d_val;
8457
8458                   if (val & DF_P1_LAZYLOAD)
8459                     {
8460                       printf (" LAZYLOAD");
8461                       val ^= DF_P1_LAZYLOAD;
8462                     }
8463                   if (val & DF_P1_GROUPPERM)
8464                     {
8465                       printf (" GROUPPERM");
8466                       val ^= DF_P1_GROUPPERM;
8467                     }
8468                   if (val != 0)
8469                     printf (" %lx", val);
8470                   puts ("");
8471                 }
8472             }
8473           break;
8474
8475         case DT_FLAGS_1:
8476           if (do_dynamic)
8477             {
8478               printf (_("Flags:"));
8479               if (entry->d_un.d_val == 0)
8480                 printf (_(" None\n"));
8481               else
8482                 {
8483                   unsigned long int val = entry->d_un.d_val;
8484
8485                   if (val & DF_1_NOW)
8486                     {
8487                       printf (" NOW");
8488                       val ^= DF_1_NOW;
8489                     }
8490                   if (val & DF_1_GLOBAL)
8491                     {
8492                       printf (" GLOBAL");
8493                       val ^= DF_1_GLOBAL;
8494                     }
8495                   if (val & DF_1_GROUP)
8496                     {
8497                       printf (" GROUP");
8498                       val ^= DF_1_GROUP;
8499                     }
8500                   if (val & DF_1_NODELETE)
8501                     {
8502                       printf (" NODELETE");
8503                       val ^= DF_1_NODELETE;
8504                     }
8505                   if (val & DF_1_LOADFLTR)
8506                     {
8507                       printf (" LOADFLTR");
8508                       val ^= DF_1_LOADFLTR;
8509                     }
8510                   if (val & DF_1_INITFIRST)
8511                     {
8512                       printf (" INITFIRST");
8513                       val ^= DF_1_INITFIRST;
8514                     }
8515                   if (val & DF_1_NOOPEN)
8516                     {
8517                       printf (" NOOPEN");
8518                       val ^= DF_1_NOOPEN;
8519                     }
8520                   if (val & DF_1_ORIGIN)
8521                     {
8522                       printf (" ORIGIN");
8523                       val ^= DF_1_ORIGIN;
8524                     }
8525                   if (val & DF_1_DIRECT)
8526                     {
8527                       printf (" DIRECT");
8528                       val ^= DF_1_DIRECT;
8529                     }
8530                   if (val & DF_1_TRANS)
8531                     {
8532                       printf (" TRANS");
8533                       val ^= DF_1_TRANS;
8534                     }
8535                   if (val & DF_1_INTERPOSE)
8536                     {
8537                       printf (" INTERPOSE");
8538                       val ^= DF_1_INTERPOSE;
8539                     }
8540                   if (val & DF_1_NODEFLIB)
8541                     {
8542                       printf (" NODEFLIB");
8543                       val ^= DF_1_NODEFLIB;
8544                     }
8545                   if (val & DF_1_NODUMP)
8546                     {
8547                       printf (" NODUMP");
8548                       val ^= DF_1_NODUMP;
8549                     }
8550                   if (val & DF_1_CONFALT)
8551                     {
8552                       printf (" CONFALT");
8553                       val ^= DF_1_CONFALT;
8554                     }
8555                   if (val & DF_1_ENDFILTEE)
8556                     {
8557                       printf (" ENDFILTEE");
8558                       val ^= DF_1_ENDFILTEE;
8559                     }
8560                   if (val & DF_1_DISPRELDNE)
8561                     {
8562                       printf (" DISPRELDNE");
8563                       val ^= DF_1_DISPRELDNE;
8564                     }
8565                   if (val & DF_1_DISPRELPND)
8566                     {
8567                       printf (" DISPRELPND");
8568                       val ^= DF_1_DISPRELPND;
8569                     }
8570                   if (val & DF_1_NODIRECT)
8571                     {
8572                       printf (" NODIRECT");
8573                       val ^= DF_1_NODIRECT;
8574                     }
8575                   if (val & DF_1_IGNMULDEF)
8576                     {
8577                       printf (" IGNMULDEF");
8578                       val ^= DF_1_IGNMULDEF;
8579                     }
8580                   if (val & DF_1_NOKSYMS)
8581                     {
8582                       printf (" NOKSYMS");
8583                       val ^= DF_1_NOKSYMS;
8584                     }
8585                   if (val & DF_1_NOHDR)
8586                     {
8587                       printf (" NOHDR");
8588                       val ^= DF_1_NOHDR;
8589                     }
8590                   if (val & DF_1_EDITED)
8591                     {
8592                       printf (" EDITED");
8593                       val ^= DF_1_EDITED;
8594                     }
8595                   if (val & DF_1_NORELOC)
8596                     {
8597                       printf (" NORELOC");
8598                       val ^= DF_1_NORELOC;
8599                     }
8600                   if (val & DF_1_SYMINTPOSE)
8601                     {
8602                       printf (" SYMINTPOSE");
8603                       val ^= DF_1_SYMINTPOSE;
8604                     }
8605                   if (val & DF_1_GLOBAUDIT)
8606                     {
8607                       printf (" GLOBAUDIT");
8608                       val ^= DF_1_GLOBAUDIT;
8609                     }
8610                   if (val & DF_1_SINGLETON)
8611                     {
8612                       printf (" SINGLETON");
8613                       val ^= DF_1_SINGLETON;
8614                     }
8615                   if (val != 0)
8616                     printf (" %lx", val);
8617                   puts ("");
8618                 }
8619             }
8620           break;
8621
8622         case DT_PLTREL:
8623           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8624           if (do_dynamic)
8625             puts (get_dynamic_type (entry->d_un.d_val));
8626           break;
8627
8628         case DT_NULL    :
8629         case DT_NEEDED  :
8630         case DT_PLTGOT  :
8631         case DT_HASH    :
8632         case DT_STRTAB  :
8633         case DT_SYMTAB  :
8634         case DT_RELA    :
8635         case DT_INIT    :
8636         case DT_FINI    :
8637         case DT_SONAME  :
8638         case DT_RPATH   :
8639         case DT_SYMBOLIC:
8640         case DT_REL     :
8641         case DT_DEBUG   :
8642         case DT_TEXTREL :
8643         case DT_JMPREL  :
8644         case DT_RUNPATH :
8645           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8646
8647           if (do_dynamic)
8648             {
8649               char * name;
8650
8651               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8652                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8653               else
8654                 name = NULL;
8655
8656               if (name)
8657                 {
8658                   switch (entry->d_tag)
8659                     {
8660                     case DT_NEEDED:
8661                       printf (_("Shared library: [%s]"), name);
8662
8663                       if (streq (name, program_interpreter))
8664                         printf (_(" program interpreter"));
8665                       break;
8666
8667                     case DT_SONAME:
8668                       printf (_("Library soname: [%s]"), name);
8669                       break;
8670
8671                     case DT_RPATH:
8672                       printf (_("Library rpath: [%s]"), name);
8673                       break;
8674
8675                     case DT_RUNPATH:
8676                       printf (_("Library runpath: [%s]"), name);
8677                       break;
8678
8679                     default:
8680                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8681                       break;
8682                     }
8683                 }
8684               else
8685                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8686
8687               putchar ('\n');
8688             }
8689           break;
8690
8691         case DT_PLTRELSZ:
8692         case DT_RELASZ  :
8693         case DT_STRSZ   :
8694         case DT_RELSZ   :
8695         case DT_RELAENT :
8696         case DT_SYMENT  :
8697         case DT_RELENT  :
8698           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8699         case DT_PLTPADSZ:
8700         case DT_MOVEENT :
8701         case DT_MOVESZ  :
8702         case DT_INIT_ARRAYSZ:
8703         case DT_FINI_ARRAYSZ:
8704         case DT_GNU_CONFLICTSZ:
8705         case DT_GNU_LIBLISTSZ:
8706           if (do_dynamic)
8707             {
8708               print_vma (entry->d_un.d_val, UNSIGNED);
8709               printf (_(" (bytes)\n"));
8710             }
8711           break;
8712
8713         case DT_VERDEFNUM:
8714         case DT_VERNEEDNUM:
8715         case DT_RELACOUNT:
8716         case DT_RELCOUNT:
8717           if (do_dynamic)
8718             {
8719               print_vma (entry->d_un.d_val, UNSIGNED);
8720               putchar ('\n');
8721             }
8722           break;
8723
8724         case DT_SYMINSZ:
8725         case DT_SYMINENT:
8726         case DT_SYMINFO:
8727         case DT_USED:
8728         case DT_INIT_ARRAY:
8729         case DT_FINI_ARRAY:
8730           if (do_dynamic)
8731             {
8732               if (entry->d_tag == DT_USED
8733                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8734                 {
8735                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8736
8737                   if (*name)
8738                     {
8739                       printf (_("Not needed object: [%s]\n"), name);
8740                       break;
8741                     }
8742                 }
8743
8744               print_vma (entry->d_un.d_val, PREFIX_HEX);
8745               putchar ('\n');
8746             }
8747           break;
8748
8749         case DT_BIND_NOW:
8750           /* The value of this entry is ignored.  */
8751           if (do_dynamic)
8752             putchar ('\n');
8753           break;
8754
8755         case DT_GNU_PRELINKED:
8756           if (do_dynamic)
8757             {
8758               struct tm * tmp;
8759               time_t atime = entry->d_un.d_val;
8760
8761               tmp = gmtime (&atime);
8762               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8763                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8764                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8765
8766             }
8767           break;
8768
8769         case DT_GNU_HASH:
8770           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8771           if (do_dynamic)
8772             {
8773               print_vma (entry->d_un.d_val, PREFIX_HEX);
8774               putchar ('\n');
8775             }
8776           break;
8777
8778         default:
8779           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8780             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8781               entry->d_un.d_val;
8782
8783           if (do_dynamic)
8784             {
8785               switch (elf_header.e_machine)
8786                 {
8787                 case EM_MIPS:
8788                 case EM_MIPS_RS3_LE:
8789                   dynamic_section_mips_val (entry);
8790                   break;
8791                 case EM_PARISC:
8792                   dynamic_section_parisc_val (entry);
8793                   break;
8794                 case EM_IA_64:
8795                   dynamic_section_ia64_val (entry);
8796                   break;
8797                 default:
8798                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8799                   putchar ('\n');
8800                 }
8801             }
8802           break;
8803         }
8804     }
8805
8806   return 1;
8807 }
8808
8809 static char *
8810 get_ver_flags (unsigned int flags)
8811 {
8812   static char buff[32];
8813
8814   buff[0] = 0;
8815
8816   if (flags == 0)
8817     return _("none");
8818
8819   if (flags & VER_FLG_BASE)
8820     strcat (buff, "BASE ");
8821
8822   if (flags & VER_FLG_WEAK)
8823     {
8824       if (flags & VER_FLG_BASE)
8825         strcat (buff, "| ");
8826
8827       strcat (buff, "WEAK ");
8828     }
8829
8830   if (flags & VER_FLG_INFO)
8831     {
8832       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8833         strcat (buff, "| ");
8834
8835       strcat (buff, "INFO ");
8836     }
8837
8838   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8839     strcat (buff, _("| <unknown>"));
8840
8841   return buff;
8842 }
8843
8844 /* Display the contents of the version sections.  */
8845
8846 static int
8847 process_version_sections (FILE * file)
8848 {
8849   Elf_Internal_Shdr * section;
8850   unsigned i;
8851   int found = 0;
8852
8853   if (! do_version)
8854     return 1;
8855
8856   for (i = 0, section = section_headers;
8857        i < elf_header.e_shnum;
8858        i++, section++)
8859     {
8860       switch (section->sh_type)
8861         {
8862         case SHT_GNU_verdef:
8863           {
8864             Elf_External_Verdef * edefs;
8865             unsigned int idx;
8866             unsigned int cnt;
8867             char * endbuf;
8868
8869             found = 1;
8870
8871             printf
8872               (_("\nVersion definition section '%s' contains %u entries:\n"),
8873                SECTION_NAME (section), section->sh_info);
8874
8875             printf (_("  Addr: 0x"));
8876             printf_vma (section->sh_addr);
8877             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8878                     (unsigned long) section->sh_offset, section->sh_link,
8879                     section->sh_link < elf_header.e_shnum
8880                     ? SECTION_NAME (section_headers + section->sh_link)
8881                     : _("<corrupt>"));
8882
8883             edefs = (Elf_External_Verdef *)
8884                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8885                           _("version definition section"));
8886             if (!edefs)
8887               break;
8888             endbuf = (char *) edefs + section->sh_size;
8889
8890             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8891               {
8892                 char * vstart;
8893                 Elf_External_Verdef * edef;
8894                 Elf_Internal_Verdef ent;
8895                 Elf_External_Verdaux * eaux;
8896                 Elf_Internal_Verdaux aux;
8897                 int j;
8898                 int isum;
8899
8900                 /* Check for very large indicies.  */
8901                 if (idx > (size_t) (endbuf - (char *) edefs))
8902                   break;
8903
8904                 vstart = ((char *) edefs) + idx;
8905                 if (vstart + sizeof (*edef) > endbuf)
8906                   break;
8907
8908                 edef = (Elf_External_Verdef *) vstart;
8909
8910                 ent.vd_version = BYTE_GET (edef->vd_version);
8911                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8912                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8913                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8914                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8915                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8916                 ent.vd_next    = BYTE_GET (edef->vd_next);
8917
8918                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8919                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8920
8921                 printf (_("  Index: %d  Cnt: %d  "),
8922                         ent.vd_ndx, ent.vd_cnt);
8923
8924                 /* Check for overflow.  */
8925                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8926                   break;
8927
8928                 vstart += ent.vd_aux;
8929
8930                 eaux = (Elf_External_Verdaux *) vstart;
8931
8932                 aux.vda_name = BYTE_GET (eaux->vda_name);
8933                 aux.vda_next = BYTE_GET (eaux->vda_next);
8934
8935                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8936                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8937                 else
8938                   printf (_("Name index: %ld\n"), aux.vda_name);
8939
8940                 isum = idx + ent.vd_aux;
8941
8942                 for (j = 1; j < ent.vd_cnt; j++)
8943                   {
8944                     /* Check for overflow.  */
8945                     if (aux.vda_next > (size_t) (endbuf - vstart))
8946                       break;
8947
8948                     isum   += aux.vda_next;
8949                     vstart += aux.vda_next;
8950
8951                     eaux = (Elf_External_Verdaux *) vstart;
8952                     if (vstart + sizeof (*eaux) > endbuf)
8953                       break;
8954
8955                     aux.vda_name = BYTE_GET (eaux->vda_name);
8956                     aux.vda_next = BYTE_GET (eaux->vda_next);
8957
8958                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8959                       printf (_("  %#06x: Parent %d: %s\n"),
8960                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8961                     else
8962                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8963                               isum, j, aux.vda_name);
8964                   }
8965
8966                 if (j < ent.vd_cnt)
8967                   printf (_("  Version def aux past end of section\n"));
8968
8969                 idx += ent.vd_next;
8970               }
8971
8972             if (cnt < section->sh_info)
8973               printf (_("  Version definition past end of section\n"));
8974
8975             free (edefs);
8976           }
8977           break;
8978
8979         case SHT_GNU_verneed:
8980           {
8981             Elf_External_Verneed * eneed;
8982             unsigned int idx;
8983             unsigned int cnt;
8984             char * endbuf;
8985
8986             found = 1;
8987
8988             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8989                     SECTION_NAME (section), section->sh_info);
8990
8991             printf (_(" Addr: 0x"));
8992             printf_vma (section->sh_addr);
8993             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8994                     (unsigned long) section->sh_offset, section->sh_link,
8995                     section->sh_link < elf_header.e_shnum
8996                     ? SECTION_NAME (section_headers + section->sh_link)
8997                     : _("<corrupt>"));
8998
8999             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9000                                                        section->sh_offset, 1,
9001                                                        section->sh_size,
9002                                                        _("Version Needs section"));
9003             if (!eneed)
9004               break;
9005             endbuf = (char *) eneed + section->sh_size;
9006
9007             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9008               {
9009                 Elf_External_Verneed * entry;
9010                 Elf_Internal_Verneed ent;
9011                 int j;
9012                 int isum;
9013                 char * vstart;
9014
9015                 if (idx > (size_t) (endbuf - (char *) eneed))
9016                   break;
9017
9018                 vstart = ((char *) eneed) + idx;
9019                 if (vstart + sizeof (*entry) > endbuf)
9020                   break;
9021
9022                 entry = (Elf_External_Verneed *) vstart;
9023
9024                 ent.vn_version = BYTE_GET (entry->vn_version);
9025                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9026                 ent.vn_file    = BYTE_GET (entry->vn_file);
9027                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9028                 ent.vn_next    = BYTE_GET (entry->vn_next);
9029
9030                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9031
9032                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9033                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9034                 else
9035                   printf (_("  File: %lx"), ent.vn_file);
9036
9037                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9038
9039                 /* Check for overflow.  */
9040                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9041                   break;
9042
9043                 vstart += ent.vn_aux;
9044
9045                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9046                   {
9047                     Elf_External_Vernaux * eaux;
9048                     Elf_Internal_Vernaux aux;
9049
9050                     if (vstart + sizeof (*eaux) > endbuf)
9051                       break;
9052                     eaux = (Elf_External_Vernaux *) vstart;
9053
9054                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9055                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9056                     aux.vna_other = BYTE_GET (eaux->vna_other);
9057                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9058                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9059
9060                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9061                       printf (_("  %#06x:   Name: %s"),
9062                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9063                     else
9064                       printf (_("  %#06x:   Name index: %lx"),
9065                               isum, aux.vna_name);
9066
9067                     printf (_("  Flags: %s  Version: %d\n"),
9068                             get_ver_flags (aux.vna_flags), aux.vna_other);
9069
9070                     /* Check for overflow.  */
9071                     if (aux.vna_next > (size_t) (endbuf - vstart))
9072                       break;
9073
9074                     isum   += aux.vna_next;
9075                     vstart += aux.vna_next;
9076                   }
9077
9078                 if (j < ent.vn_cnt)
9079                   warn (_("Missing Version Needs auxillary information\n"));
9080
9081                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9082                   {
9083                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9084                     cnt = section->sh_info;
9085                     break;
9086                   }
9087                 idx += ent.vn_next;
9088               }
9089
9090             if (cnt < section->sh_info)
9091               warn (_("Missing Version Needs information\n"));
9092
9093             free (eneed);
9094           }
9095           break;
9096
9097         case SHT_GNU_versym:
9098           {
9099             Elf_Internal_Shdr * link_section;
9100             int total;
9101             int cnt;
9102             unsigned char * edata;
9103             unsigned short * data;
9104             char * strtab;
9105             Elf_Internal_Sym * symbols;
9106             Elf_Internal_Shdr * string_sec;
9107             unsigned long num_syms;
9108             long off;
9109
9110             if (section->sh_link >= elf_header.e_shnum)
9111               break;
9112
9113             link_section = section_headers + section->sh_link;
9114             total = section->sh_size / sizeof (Elf_External_Versym);
9115
9116             if (link_section->sh_link >= elf_header.e_shnum)
9117               break;
9118
9119             found = 1;
9120
9121             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9122             if (symbols == NULL)
9123               break;
9124
9125             string_sec = section_headers + link_section->sh_link;
9126
9127             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9128                                         string_sec->sh_size,
9129                                         _("version string table"));
9130             if (!strtab)
9131               {
9132                 free (symbols);
9133                 break;
9134               }
9135
9136             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9137                     SECTION_NAME (section), total);
9138
9139             printf (_(" Addr: "));
9140             printf_vma (section->sh_addr);
9141             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9142                     (unsigned long) section->sh_offset, section->sh_link,
9143                     SECTION_NAME (link_section));
9144
9145             off = offset_from_vma (file,
9146                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9147                                    total * sizeof (short));
9148             edata = (unsigned char *) get_data (NULL, file, off, total,
9149                                                 sizeof (short),
9150                                                 _("version symbol data"));
9151             if (!edata)
9152               {
9153                 free (strtab);
9154                 free (symbols);
9155                 break;
9156               }
9157
9158             data = (short unsigned int *) cmalloc (total, sizeof (short));
9159
9160             for (cnt = total; cnt --;)
9161               data[cnt] = byte_get (edata + cnt * sizeof (short),
9162                                     sizeof (short));
9163
9164             free (edata);
9165
9166             for (cnt = 0; cnt < total; cnt += 4)
9167               {
9168                 int j, nn;
9169                 int check_def, check_need;
9170                 char * name;
9171
9172                 printf ("  %03x:", cnt);
9173
9174                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9175                   switch (data[cnt + j])
9176                     {
9177                     case 0:
9178                       fputs (_("   0 (*local*)    "), stdout);
9179                       break;
9180
9181                     case 1:
9182                       fputs (_("   1 (*global*)   "), stdout);
9183                       break;
9184
9185                     default:
9186                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9187                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9188
9189                       /* If this index value is greater than the size of the symbols
9190                          array, break to avoid an out-of-bounds read.  */
9191                       if ((unsigned long)(cnt + j) >= num_syms)
9192                         {
9193                           warn (_("invalid index into symbol array\n"));
9194                           break;
9195                         }
9196
9197                       check_def = 1;
9198                       check_need = 1;
9199                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9200                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9201                              != SHT_NOBITS)
9202                         {
9203                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9204                             check_def = 0;
9205                           else
9206                             check_need = 0;
9207                         }
9208
9209                       if (check_need
9210                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9211                         {
9212                           Elf_Internal_Verneed ivn;
9213                           unsigned long offset;
9214
9215                           offset = offset_from_vma
9216                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9217                              sizeof (Elf_External_Verneed));
9218
9219                           do
9220                             {
9221                               Elf_Internal_Vernaux ivna;
9222                               Elf_External_Verneed evn;
9223                               Elf_External_Vernaux evna;
9224                               unsigned long a_off;
9225
9226                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9227                                             _("version need")) == NULL)
9228                                 break;
9229
9230                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9231                               ivn.vn_next = BYTE_GET (evn.vn_next);
9232
9233                               a_off = offset + ivn.vn_aux;
9234
9235                               do
9236                                 {
9237                                   if (get_data (&evna, file, a_off, sizeof (evna),
9238                                                 1, _("version need aux (2)")) == NULL)
9239                                     {
9240                                       ivna.vna_next  = 0;
9241                                       ivna.vna_other = 0;
9242                                     }
9243                                   else
9244                                     {
9245                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9246                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9247                                     }
9248
9249                                   a_off += ivna.vna_next;
9250                                 }
9251                               while (ivna.vna_other != data[cnt + j]
9252                                      && ivna.vna_next != 0);
9253
9254                               if (ivna.vna_other == data[cnt + j])
9255                                 {
9256                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9257
9258                                   if (ivna.vna_name >= string_sec->sh_size)
9259                                     name = _("*invalid*");
9260                                   else
9261                                     name = strtab + ivna.vna_name;
9262                                   nn += printf ("(%s%-*s",
9263                                                 name,
9264                                                 12 - (int) strlen (name),
9265                                                 ")");
9266                                   check_def = 0;
9267                                   break;
9268                                 }
9269
9270                               offset += ivn.vn_next;
9271                             }
9272                           while (ivn.vn_next);
9273                         }
9274
9275                       if (check_def && data[cnt + j] != 0x8001
9276                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9277                         {
9278                           Elf_Internal_Verdef ivd;
9279                           Elf_External_Verdef evd;
9280                           unsigned long offset;
9281
9282                           offset = offset_from_vma
9283                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9284                              sizeof evd);
9285
9286                           do
9287                             {
9288                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9289                                             _("version def")) == NULL)
9290                                 {
9291                                   ivd.vd_next = 0;
9292                                   ivd.vd_ndx  = 0;
9293                                 }
9294                               else
9295                                 {
9296                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9297                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9298                                 }
9299
9300                               offset += ivd.vd_next;
9301                             }
9302                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9303                                  && ivd.vd_next != 0);
9304
9305                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9306                             {
9307                               Elf_External_Verdaux evda;
9308                               Elf_Internal_Verdaux ivda;
9309
9310                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9311
9312                               if (get_data (&evda, file,
9313                                             offset - ivd.vd_next + ivd.vd_aux,
9314                                             sizeof (evda), 1,
9315                                             _("version def aux")) == NULL)
9316                                 break;
9317
9318                               ivda.vda_name = BYTE_GET (evda.vda_name);
9319
9320                               if (ivda.vda_name >= string_sec->sh_size)
9321                                 name = _("*invalid*");
9322                               else
9323                                 name = strtab + ivda.vda_name;
9324                               nn += printf ("(%s%-*s",
9325                                             name,
9326                                             12 - (int) strlen (name),
9327                                             ")");
9328                             }
9329                         }
9330
9331                       if (nn < 18)
9332                         printf ("%*c", 18 - nn, ' ');
9333                     }
9334
9335                 putchar ('\n');
9336               }
9337
9338             free (data);
9339             free (strtab);
9340             free (symbols);
9341           }
9342           break;
9343
9344         default:
9345           break;
9346         }
9347     }
9348
9349   if (! found)
9350     printf (_("\nNo version information found in this file.\n"));
9351
9352   return 1;
9353 }
9354
9355 static const char *
9356 get_symbol_binding (unsigned int binding)
9357 {
9358   static char buff[32];
9359
9360   switch (binding)
9361     {
9362     case STB_LOCAL:     return "LOCAL";
9363     case STB_GLOBAL:    return "GLOBAL";
9364     case STB_WEAK:      return "WEAK";
9365     default:
9366       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9367         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9368                   binding);
9369       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9370         {
9371           if (binding == STB_GNU_UNIQUE
9372               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9373                   /* GNU is still using the default value 0.  */
9374                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9375             return "UNIQUE";
9376           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9377         }
9378       else
9379         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9380       return buff;
9381     }
9382 }
9383
9384 static const char *
9385 get_symbol_type (unsigned int type)
9386 {
9387   static char buff[32];
9388
9389   switch (type)
9390     {
9391     case STT_NOTYPE:    return "NOTYPE";
9392     case STT_OBJECT:    return "OBJECT";
9393     case STT_FUNC:      return "FUNC";
9394     case STT_SECTION:   return "SECTION";
9395     case STT_FILE:      return "FILE";
9396     case STT_COMMON:    return "COMMON";
9397     case STT_TLS:       return "TLS";
9398     case STT_RELC:      return "RELC";
9399     case STT_SRELC:     return "SRELC";
9400     default:
9401       if (type >= STT_LOPROC && type <= STT_HIPROC)
9402         {
9403           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9404             return "THUMB_FUNC";
9405
9406           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9407             return "REGISTER";
9408
9409           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9410             return "PARISC_MILLI";
9411
9412           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9413         }
9414       else if (type >= STT_LOOS && type <= STT_HIOS)
9415         {
9416           if (elf_header.e_machine == EM_PARISC)
9417             {
9418               if (type == STT_HP_OPAQUE)
9419                 return "HP_OPAQUE";
9420               if (type == STT_HP_STUB)
9421                 return "HP_STUB";
9422             }
9423
9424           if (type == STT_GNU_IFUNC
9425               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9426                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9427                   /* GNU is still using the default value 0.  */
9428                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9429             return "IFUNC";
9430
9431           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9432         }
9433       else
9434         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9435       return buff;
9436     }
9437 }
9438
9439 static const char *
9440 get_symbol_visibility (unsigned int visibility)
9441 {
9442   switch (visibility)
9443     {
9444     case STV_DEFAULT:   return "DEFAULT";
9445     case STV_INTERNAL:  return "INTERNAL";
9446     case STV_HIDDEN:    return "HIDDEN";
9447     case STV_PROTECTED: return "PROTECTED";
9448     default: abort ();
9449     }
9450 }
9451
9452 static const char *
9453 get_mips_symbol_other (unsigned int other)
9454 {
9455   switch (other)
9456     {
9457     case STO_OPTIONAL:
9458       return "OPTIONAL";
9459     case STO_MIPS_PLT:
9460       return "MIPS PLT";
9461     case STO_MIPS_PIC:
9462       return "MIPS PIC";
9463     case STO_MICROMIPS:
9464       return "MICROMIPS";
9465     case STO_MICROMIPS | STO_MIPS_PIC:
9466       return "MICROMIPS, MIPS PIC";
9467     case STO_MIPS16:
9468       return "MIPS16";
9469     default:
9470       return NULL;
9471     }
9472 }
9473
9474 static const char *
9475 get_ia64_symbol_other (unsigned int other)
9476 {
9477   if (is_ia64_vms ())
9478     {
9479       static char res[32];
9480
9481       res[0] = 0;
9482
9483       /* Function types is for images and .STB files only.  */
9484       switch (elf_header.e_type)
9485         {
9486         case ET_DYN:
9487         case ET_EXEC:
9488           switch (VMS_ST_FUNC_TYPE (other))
9489             {
9490             case VMS_SFT_CODE_ADDR:
9491               strcat (res, " CA");
9492               break;
9493             case VMS_SFT_SYMV_IDX:
9494               strcat (res, " VEC");
9495               break;
9496             case VMS_SFT_FD:
9497               strcat (res, " FD");
9498               break;
9499             case VMS_SFT_RESERVE:
9500               strcat (res, " RSV");
9501               break;
9502             default:
9503               abort ();
9504             }
9505           break;
9506         default:
9507           break;
9508         }
9509       switch (VMS_ST_LINKAGE (other))
9510         {
9511         case VMS_STL_IGNORE:
9512           strcat (res, " IGN");
9513           break;
9514         case VMS_STL_RESERVE:
9515           strcat (res, " RSV");
9516           break;
9517         case VMS_STL_STD:
9518           strcat (res, " STD");
9519           break;
9520         case VMS_STL_LNK:
9521           strcat (res, " LNK");
9522           break;
9523         default:
9524           abort ();
9525         }
9526
9527       if (res[0] != 0)
9528         return res + 1;
9529       else
9530         return res;
9531     }
9532   return NULL;
9533 }
9534
9535 static const char *
9536 get_ppc64_symbol_other (unsigned int other)
9537 {
9538   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9539     {
9540       static char buf[32];
9541       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9542                 PPC64_LOCAL_ENTRY_OFFSET (other));
9543       return buf;
9544     }
9545   return NULL;
9546 }
9547
9548 static const char *
9549 get_symbol_other (unsigned int other)
9550 {
9551   const char * result = NULL;
9552   static char buff [32];
9553
9554   if (other == 0)
9555     return "";
9556
9557   switch (elf_header.e_machine)
9558     {
9559     case EM_MIPS:
9560       result = get_mips_symbol_other (other);
9561       break;
9562     case EM_IA_64:
9563       result = get_ia64_symbol_other (other);
9564       break;
9565     case EM_PPC64:
9566       result = get_ppc64_symbol_other (other);
9567       break;
9568     default:
9569       break;
9570     }
9571
9572   if (result)
9573     return result;
9574
9575   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9576   return buff;
9577 }
9578
9579 static const char *
9580 get_symbol_index_type (unsigned int type)
9581 {
9582   static char buff[32];
9583
9584   switch (type)
9585     {
9586     case SHN_UNDEF:     return "UND";
9587     case SHN_ABS:       return "ABS";
9588     case SHN_COMMON:    return "COM";
9589     default:
9590       if (type == SHN_IA_64_ANSI_COMMON
9591           && elf_header.e_machine == EM_IA_64
9592           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9593         return "ANSI_COM";
9594       else if ((elf_header.e_machine == EM_X86_64
9595                 || elf_header.e_machine == EM_L1OM
9596                 || elf_header.e_machine == EM_K1OM)
9597                && type == SHN_X86_64_LCOMMON)
9598         return "LARGE_COM";
9599       else if ((type == SHN_MIPS_SCOMMON
9600                 && elf_header.e_machine == EM_MIPS)
9601                || (type == SHN_TIC6X_SCOMMON
9602                    && elf_header.e_machine == EM_TI_C6000))
9603         return "SCOM";
9604       else if (type == SHN_MIPS_SUNDEFINED
9605                && elf_header.e_machine == EM_MIPS)
9606         return "SUND";
9607       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9608         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9609       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9610         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9611       else if (type >= SHN_LORESERVE)
9612         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9613       else if (type >= elf_header.e_shnum)
9614         sprintf (buff, _("bad section index[%3d]"), type);
9615       else
9616         sprintf (buff, "%3d", type);
9617       break;
9618     }
9619
9620   return buff;
9621 }
9622
9623 static bfd_vma *
9624 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9625 {
9626   unsigned char * e_data;
9627   bfd_vma * i_data;
9628
9629   e_data = (unsigned char *) cmalloc (number, ent_size);
9630
9631   if (e_data == NULL)
9632     {
9633       error (_("Out of memory\n"));
9634       return NULL;
9635     }
9636
9637   if (fread (e_data, ent_size, number, file) != number)
9638     {
9639       error (_("Unable to read in dynamic data\n"));
9640       return NULL;
9641     }
9642
9643   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9644
9645   if (i_data == NULL)
9646     {
9647       error (_("Out of memory\n"));
9648       free (e_data);
9649       return NULL;
9650     }
9651
9652   while (number--)
9653     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9654
9655   free (e_data);
9656
9657   return i_data;
9658 }
9659
9660 static void
9661 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9662 {
9663   Elf_Internal_Sym * psym;
9664   int n;
9665
9666   n = print_vma (si, DEC_5);
9667   if (n < 5)
9668     fputs (&"     "[n], stdout);
9669   printf (" %3lu: ", hn);
9670
9671   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9672     {
9673       printf (_("<No info available>\n"));
9674       return;
9675     }
9676
9677   psym = dynamic_symbols + si;
9678   print_vma (psym->st_value, LONG_HEX);
9679   putchar (' ');
9680   print_vma (psym->st_size, DEC_5);
9681
9682   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9683   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9684   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9685   /* Check to see if any other bits in the st_other field are set.
9686      Note - displaying this information disrupts the layout of the
9687      table being generated, but for the moment this case is very
9688      rare.  */
9689   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9690     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9691   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9692   if (VALID_DYNAMIC_NAME (psym->st_name))
9693     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9694   else
9695     printf (_(" <corrupt: %14ld>"), psym->st_name);
9696   putchar ('\n');
9697 }
9698
9699 /* Dump the symbol table.  */
9700 static int
9701 process_symbol_table (FILE * file)
9702 {
9703   Elf_Internal_Shdr * section;
9704   bfd_vma nbuckets = 0;
9705   bfd_vma nchains = 0;
9706   bfd_vma * buckets = NULL;
9707   bfd_vma * chains = NULL;
9708   bfd_vma ngnubuckets = 0;
9709   bfd_vma * gnubuckets = NULL;
9710   bfd_vma * gnuchains = NULL;
9711   bfd_vma gnusymidx = 0;
9712
9713   if (!do_syms && !do_dyn_syms && !do_histogram)
9714     return 1;
9715
9716   if (dynamic_info[DT_HASH]
9717       && (do_histogram
9718           || (do_using_dynamic
9719               && !do_dyn_syms
9720               && dynamic_strings != NULL)))
9721     {
9722       unsigned char nb[8];
9723       unsigned char nc[8];
9724       int hash_ent_size = 4;
9725
9726       if ((elf_header.e_machine == EM_ALPHA
9727            || elf_header.e_machine == EM_S390
9728            || elf_header.e_machine == EM_S390_OLD)
9729           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9730         hash_ent_size = 8;
9731
9732       if (fseek (file,
9733                  (archive_file_offset
9734                   + offset_from_vma (file, dynamic_info[DT_HASH],
9735                                      sizeof nb + sizeof nc)),
9736                  SEEK_SET))
9737         {
9738           error (_("Unable to seek to start of dynamic information\n"));
9739           goto no_hash;
9740         }
9741
9742       if (fread (nb, hash_ent_size, 1, file) != 1)
9743         {
9744           error (_("Failed to read in number of buckets\n"));
9745           goto no_hash;
9746         }
9747
9748       if (fread (nc, hash_ent_size, 1, file) != 1)
9749         {
9750           error (_("Failed to read in number of chains\n"));
9751           goto no_hash;
9752         }
9753
9754       nbuckets = byte_get (nb, hash_ent_size);
9755       nchains  = byte_get (nc, hash_ent_size);
9756
9757       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9758       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9759
9760     no_hash:
9761       if (buckets == NULL || chains == NULL)
9762         {
9763           if (do_using_dynamic)
9764             return 0;
9765           free (buckets);
9766           free (chains);
9767           buckets = NULL;
9768           chains = NULL;
9769           nbuckets = 0;
9770           nchains = 0;
9771         }
9772     }
9773
9774   if (dynamic_info_DT_GNU_HASH
9775       && (do_histogram
9776           || (do_using_dynamic
9777               && !do_dyn_syms
9778               && dynamic_strings != NULL)))
9779     {
9780       unsigned char nb[16];
9781       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9782       bfd_vma buckets_vma;
9783
9784       if (fseek (file,
9785                  (archive_file_offset
9786                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9787                                      sizeof nb)),
9788                  SEEK_SET))
9789         {
9790           error (_("Unable to seek to start of dynamic information\n"));
9791           goto no_gnu_hash;
9792         }
9793
9794       if (fread (nb, 16, 1, file) != 1)
9795         {
9796           error (_("Failed to read in number of buckets\n"));
9797           goto no_gnu_hash;
9798         }
9799
9800       ngnubuckets = byte_get (nb, 4);
9801       gnusymidx = byte_get (nb + 4, 4);
9802       bitmaskwords = byte_get (nb + 8, 4);
9803       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9804       if (is_32bit_elf)
9805         buckets_vma += bitmaskwords * 4;
9806       else
9807         buckets_vma += bitmaskwords * 8;
9808
9809       if (fseek (file,
9810                  (archive_file_offset
9811                   + offset_from_vma (file, buckets_vma, 4)),
9812                  SEEK_SET))
9813         {
9814           error (_("Unable to seek to start of dynamic information\n"));
9815           goto no_gnu_hash;
9816         }
9817
9818       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9819
9820       if (gnubuckets == NULL)
9821         goto no_gnu_hash;
9822
9823       for (i = 0; i < ngnubuckets; i++)
9824         if (gnubuckets[i] != 0)
9825           {
9826             if (gnubuckets[i] < gnusymidx)
9827               return 0;
9828
9829             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9830               maxchain = gnubuckets[i];
9831           }
9832
9833       if (maxchain == 0xffffffff)
9834         goto no_gnu_hash;
9835
9836       maxchain -= gnusymidx;
9837
9838       if (fseek (file,
9839                  (archive_file_offset
9840                   + offset_from_vma (file, buckets_vma
9841                                            + 4 * (ngnubuckets + maxchain), 4)),
9842                  SEEK_SET))
9843         {
9844           error (_("Unable to seek to start of dynamic information\n"));
9845           goto no_gnu_hash;
9846         }
9847
9848       do
9849         {
9850           if (fread (nb, 4, 1, file) != 1)
9851             {
9852               error (_("Failed to determine last chain length\n"));
9853               goto no_gnu_hash;
9854             }
9855
9856           if (maxchain + 1 == 0)
9857             goto no_gnu_hash;
9858
9859           ++maxchain;
9860         }
9861       while ((byte_get (nb, 4) & 1) == 0);
9862
9863       if (fseek (file,
9864                  (archive_file_offset
9865                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9866                  SEEK_SET))
9867         {
9868           error (_("Unable to seek to start of dynamic information\n"));
9869           goto no_gnu_hash;
9870         }
9871
9872       gnuchains = get_dynamic_data (file, maxchain, 4);
9873
9874     no_gnu_hash:
9875       if (gnuchains == NULL)
9876         {
9877           free (gnubuckets);
9878           gnubuckets = NULL;
9879           ngnubuckets = 0;
9880           if (do_using_dynamic)
9881             return 0;
9882         }
9883     }
9884
9885   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9886       && do_syms
9887       && do_using_dynamic
9888       && dynamic_strings != NULL)
9889     {
9890       unsigned long hn;
9891
9892       if (dynamic_info[DT_HASH])
9893         {
9894           bfd_vma si;
9895
9896           printf (_("\nSymbol table for image:\n"));
9897           if (is_32bit_elf)
9898             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9899           else
9900             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9901
9902           for (hn = 0; hn < nbuckets; hn++)
9903             {
9904               if (! buckets[hn])
9905                 continue;
9906
9907               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9908                 print_dynamic_symbol (si, hn);
9909             }
9910         }
9911
9912       if (dynamic_info_DT_GNU_HASH)
9913         {
9914           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9915           if (is_32bit_elf)
9916             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9917           else
9918             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9919
9920           for (hn = 0; hn < ngnubuckets; ++hn)
9921             if (gnubuckets[hn] != 0)
9922               {
9923                 bfd_vma si = gnubuckets[hn];
9924                 bfd_vma off = si - gnusymidx;
9925
9926                 do
9927                   {
9928                     print_dynamic_symbol (si, hn);
9929                     si++;
9930                   }
9931                 while ((gnuchains[off++] & 1) == 0);
9932               }
9933         }
9934     }
9935   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9936     {
9937       unsigned int i;
9938
9939       for (i = 0, section = section_headers;
9940            i < elf_header.e_shnum;
9941            i++, section++)
9942         {
9943           unsigned int si;
9944           char * strtab = NULL;
9945           unsigned long int strtab_size = 0;
9946           Elf_Internal_Sym * symtab;
9947           Elf_Internal_Sym * psym;
9948           unsigned long num_syms;
9949
9950           if ((section->sh_type != SHT_SYMTAB
9951                && section->sh_type != SHT_DYNSYM)
9952               || (!do_syms
9953                   && section->sh_type == SHT_SYMTAB))
9954             continue;
9955
9956           if (section->sh_entsize == 0)
9957             {
9958               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9959                       SECTION_NAME (section));
9960               continue;
9961             }
9962
9963           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9964                   SECTION_NAME (section),
9965                   (unsigned long) (section->sh_size / section->sh_entsize));
9966
9967           if (is_32bit_elf)
9968             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9969           else
9970             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9971
9972           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9973           if (symtab == NULL)
9974             continue;
9975
9976           if (section->sh_link == elf_header.e_shstrndx)
9977             {
9978               strtab = string_table;
9979               strtab_size = string_table_length;
9980             }
9981           else if (section->sh_link < elf_header.e_shnum)
9982             {
9983               Elf_Internal_Shdr * string_sec;
9984
9985               string_sec = section_headers + section->sh_link;
9986
9987               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9988                                           1, string_sec->sh_size,
9989                                           _("string table"));
9990               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9991             }
9992
9993           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9994             {
9995               printf ("%6d: ", si);
9996               print_vma (psym->st_value, LONG_HEX);
9997               putchar (' ');
9998               print_vma (psym->st_size, DEC_5);
9999               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10000               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10001               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10002               /* Check to see if any other bits in the st_other field are set.
10003                  Note - displaying this information disrupts the layout of the
10004                  table being generated, but for the moment this case is very rare.  */
10005               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10006                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10007               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10008               print_symbol (25, psym->st_name < strtab_size
10009                             ? strtab + psym->st_name : _("<corrupt>"));
10010
10011               if (section->sh_type == SHT_DYNSYM
10012                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10013                 {
10014                   unsigned char data[2];
10015                   unsigned short vers_data;
10016                   unsigned long offset;
10017                   int is_nobits;
10018                   int check_def;
10019
10020                   offset = offset_from_vma
10021                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10022                      sizeof data + si * sizeof (vers_data));
10023
10024                   if (get_data (&data, file, offset + si * sizeof (vers_data),
10025                                 sizeof (data), 1, _("version data")) == NULL)
10026                     break;
10027
10028                   vers_data = byte_get (data, 2);
10029
10030                   is_nobits = (psym->st_shndx < elf_header.e_shnum
10031                                && section_headers[psym->st_shndx].sh_type
10032                                   == SHT_NOBITS);
10033
10034                   check_def = (psym->st_shndx != SHN_UNDEF);
10035
10036                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10037                     {
10038                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10039                           && (is_nobits || ! check_def))
10040                         {
10041                           Elf_External_Verneed evn;
10042                           Elf_Internal_Verneed ivn;
10043                           Elf_Internal_Vernaux ivna;
10044
10045                           /* We must test both.  */
10046                           offset = offset_from_vma
10047                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10048                              sizeof evn);
10049
10050                           do
10051                             {
10052                               unsigned long vna_off;
10053
10054                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10055                                             _("version need")) == NULL)
10056                                 {
10057                                   ivna.vna_next = 0;
10058                                   ivna.vna_other = 0;
10059                                   ivna.vna_name = 0;
10060                                   break;
10061                                 }
10062
10063                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10064                               ivn.vn_next = BYTE_GET (evn.vn_next);
10065
10066                               vna_off = offset + ivn.vn_aux;
10067
10068                               do
10069                                 {
10070                                   Elf_External_Vernaux evna;
10071
10072                                   if (get_data (&evna, file, vna_off,
10073                                                 sizeof (evna), 1,
10074                                                 _("version need aux (3)")) == NULL)
10075                                     {
10076                                       ivna.vna_next = 0;
10077                                       ivna.vna_other = 0;
10078                                       ivna.vna_name = 0;
10079                                     }
10080                                   else
10081                                     {
10082                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10083                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10084                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
10085                                     }
10086
10087                                   vna_off += ivna.vna_next;
10088                                 }
10089                               while (ivna.vna_other != vers_data
10090                                      && ivna.vna_next != 0);
10091
10092                               if (ivna.vna_other == vers_data)
10093                                 break;
10094
10095                               offset += ivn.vn_next;
10096                             }
10097                           while (ivn.vn_next != 0);
10098
10099                           if (ivna.vna_other == vers_data)
10100                             {
10101                               printf ("@%s (%d)",
10102                                       ivna.vna_name < strtab_size
10103                                       ? strtab + ivna.vna_name : _("<corrupt>"),
10104                                       ivna.vna_other);
10105                               check_def = 0;
10106                             }
10107                           else if (! is_nobits)
10108                             error (_("bad dynamic symbol\n"));
10109                           else
10110                             check_def = 1;
10111                         }
10112
10113                       if (check_def)
10114                         {
10115                           if (vers_data != 0x8001
10116                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10117                             {
10118                               Elf_Internal_Verdef ivd;
10119                               Elf_Internal_Verdaux ivda;
10120                               Elf_External_Verdaux evda;
10121                               unsigned long off;
10122
10123                               off = offset_from_vma
10124                                 (file,
10125                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10126                                  sizeof (Elf_External_Verdef));
10127
10128                               do
10129                                 {
10130                                   Elf_External_Verdef evd;
10131
10132                                   if (get_data (&evd, file, off, sizeof (evd),
10133                                                 1, _("version def")) == NULL)
10134                                     {
10135                                       ivd.vd_ndx = 0;
10136                                       ivd.vd_aux = 0;
10137                                       ivd.vd_next = 0;
10138                                     }
10139                                   else
10140                                     {
10141                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10142                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
10143                                       ivd.vd_next = BYTE_GET (evd.vd_next);
10144                                     }
10145
10146                                   off += ivd.vd_next;
10147                                 }
10148                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10149                                      && ivd.vd_next != 0);
10150
10151                               off -= ivd.vd_next;
10152                               off += ivd.vd_aux;
10153
10154                               if (get_data (&evda, file, off, sizeof (evda),
10155                                             1, _("version def aux")) == NULL)
10156                                 break;
10157
10158                               ivda.vda_name = BYTE_GET (evda.vda_name);
10159
10160                               if (psym->st_name != ivda.vda_name)
10161                                 printf ((vers_data & VERSYM_HIDDEN)
10162                                         ? "@%s" : "@@%s",
10163                                         ivda.vda_name < strtab_size
10164                                         ? strtab + ivda.vda_name : _("<corrupt>"));
10165                             }
10166                         }
10167                     }
10168                 }
10169
10170               putchar ('\n');
10171             }
10172
10173           free (symtab);
10174           if (strtab != string_table)
10175             free (strtab);
10176         }
10177     }
10178   else if (do_syms)
10179     printf
10180       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10181
10182   if (do_histogram && buckets != NULL)
10183     {
10184       unsigned long * lengths;
10185       unsigned long * counts;
10186       unsigned long hn;
10187       bfd_vma si;
10188       unsigned long maxlength = 0;
10189       unsigned long nzero_counts = 0;
10190       unsigned long nsyms = 0;
10191
10192       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10193               (unsigned long) nbuckets);
10194       printf (_(" Length  Number     %% of total  Coverage\n"));
10195
10196       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10197       if (lengths == NULL)
10198         {
10199           error (_("Out of memory\n"));
10200           return 0;
10201         }
10202       for (hn = 0; hn < nbuckets; ++hn)
10203         {
10204           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10205             {
10206               ++nsyms;
10207               if (maxlength < ++lengths[hn])
10208                 ++maxlength;
10209
10210               /* PR binutils/17531: A corrupt binary could contain broken
10211                  histogram data.  Do not go into an infinite loop trying
10212                  to process it.  */
10213               if (chains[si] == si)
10214                 {
10215                   error (_("histogram chain links to itself\n"));
10216                   break;
10217                 }
10218             }
10219         }
10220
10221       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10222       if (counts == NULL)
10223         {
10224           free (lengths);
10225           error (_("Out of memory\n"));
10226           return 0;
10227         }
10228
10229       for (hn = 0; hn < nbuckets; ++hn)
10230         ++counts[lengths[hn]];
10231
10232       if (nbuckets > 0)
10233         {
10234           unsigned long i;
10235           printf ("      0  %-10lu (%5.1f%%)\n",
10236                   counts[0], (counts[0] * 100.0) / nbuckets);
10237           for (i = 1; i <= maxlength; ++i)
10238             {
10239               nzero_counts += counts[i] * i;
10240               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10241                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10242                       (nzero_counts * 100.0) / nsyms);
10243             }
10244         }
10245
10246       free (counts);
10247       free (lengths);
10248     }
10249
10250   if (buckets != NULL)
10251     {
10252       free (buckets);
10253       free (chains);
10254     }
10255
10256   if (do_histogram && gnubuckets != NULL)
10257     {
10258       unsigned long * lengths;
10259       unsigned long * counts;
10260       unsigned long hn;
10261       unsigned long maxlength = 0;
10262       unsigned long nzero_counts = 0;
10263       unsigned long nsyms = 0;
10264
10265       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10266       if (lengths == NULL)
10267         {
10268           error (_("Out of memory\n"));
10269           return 0;
10270         }
10271
10272       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10273               (unsigned long) ngnubuckets);
10274       printf (_(" Length  Number     %% of total  Coverage\n"));
10275
10276       for (hn = 0; hn < ngnubuckets; ++hn)
10277         if (gnubuckets[hn] != 0)
10278           {
10279             bfd_vma off, length = 1;
10280
10281             for (off = gnubuckets[hn] - gnusymidx;
10282                  (gnuchains[off] & 1) == 0; ++off)
10283               ++length;
10284             lengths[hn] = length;
10285             if (length > maxlength)
10286               maxlength = length;
10287             nsyms += length;
10288           }
10289
10290       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10291       if (counts == NULL)
10292         {
10293           free (lengths);
10294           error (_("Out of memory\n"));
10295           return 0;
10296         }
10297
10298       for (hn = 0; hn < ngnubuckets; ++hn)
10299         ++counts[lengths[hn]];
10300
10301       if (ngnubuckets > 0)
10302         {
10303           unsigned long j;
10304           printf ("      0  %-10lu (%5.1f%%)\n",
10305                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10306           for (j = 1; j <= maxlength; ++j)
10307             {
10308               nzero_counts += counts[j] * j;
10309               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10310                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10311                       (nzero_counts * 100.0) / nsyms);
10312             }
10313         }
10314
10315       free (counts);
10316       free (lengths);
10317       free (gnubuckets);
10318       free (gnuchains);
10319     }
10320
10321   return 1;
10322 }
10323
10324 static int
10325 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10326 {
10327   unsigned int i;
10328
10329   if (dynamic_syminfo == NULL
10330       || !do_dynamic)
10331     /* No syminfo, this is ok.  */
10332     return 1;
10333
10334   /* There better should be a dynamic symbol section.  */
10335   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10336     return 0;
10337
10338   if (dynamic_addr)
10339     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10340             dynamic_syminfo_offset, dynamic_syminfo_nent);
10341
10342   printf (_(" Num: Name                           BoundTo     Flags\n"));
10343   for (i = 0; i < dynamic_syminfo_nent; ++i)
10344     {
10345       unsigned short int flags = dynamic_syminfo[i].si_flags;
10346
10347       printf ("%4d: ", i);
10348       assert (i <  num_dynamic_syms);
10349       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10350         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10351       else
10352         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10353       putchar (' ');
10354
10355       switch (dynamic_syminfo[i].si_boundto)
10356         {
10357         case SYMINFO_BT_SELF:
10358           fputs ("SELF       ", stdout);
10359           break;
10360         case SYMINFO_BT_PARENT:
10361           fputs ("PARENT     ", stdout);
10362           break;
10363         default:
10364           if (dynamic_syminfo[i].si_boundto > 0
10365               && dynamic_syminfo[i].si_boundto < dynamic_nent
10366               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10367             {
10368               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10369               putchar (' ' );
10370             }
10371           else
10372             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10373           break;
10374         }
10375
10376       if (flags & SYMINFO_FLG_DIRECT)
10377         printf (" DIRECT");
10378       if (flags & SYMINFO_FLG_PASSTHRU)
10379         printf (" PASSTHRU");
10380       if (flags & SYMINFO_FLG_COPY)
10381         printf (" COPY");
10382       if (flags & SYMINFO_FLG_LAZYLOAD)
10383         printf (" LAZYLOAD");
10384
10385       puts ("");
10386     }
10387
10388   return 1;
10389 }
10390
10391 /* Check to see if the given reloc needs to be handled in a target specific
10392    manner.  If so then process the reloc and return TRUE otherwise return
10393    FALSE.  */
10394
10395 static bfd_boolean
10396 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10397                                 unsigned char *     start,
10398                                 Elf_Internal_Sym *  symtab)
10399 {
10400   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10401
10402   switch (elf_header.e_machine)
10403     {
10404     case EM_MSP430:
10405     case EM_MSP430_OLD:
10406       {
10407         static Elf_Internal_Sym * saved_sym = NULL;
10408
10409         switch (reloc_type)
10410           {
10411           case 10: /* R_MSP430_SYM_DIFF */
10412             if (uses_msp430x_relocs ())
10413               break;
10414           case 21: /* R_MSP430X_SYM_DIFF */
10415             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10416             return TRUE;
10417
10418           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10419           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10420             goto handle_sym_diff;
10421
10422           case 5: /* R_MSP430_16_BYTE */
10423           case 9: /* R_MSP430_8 */
10424             if (uses_msp430x_relocs ())
10425               break;
10426             goto handle_sym_diff;
10427
10428           case 2: /* R_MSP430_ABS16 */
10429           case 15: /* R_MSP430X_ABS16 */
10430             if (! uses_msp430x_relocs ())
10431               break;
10432             goto handle_sym_diff;
10433
10434           handle_sym_diff:
10435             if (saved_sym != NULL)
10436               {
10437                 bfd_vma value;
10438
10439                 value = reloc->r_addend
10440                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10441                      - saved_sym->st_value);
10442
10443                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10444
10445                 saved_sym = NULL;
10446                 return TRUE;
10447               }
10448             break;
10449
10450           default:
10451             if (saved_sym != NULL)
10452               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10453             break;
10454           }
10455         break;
10456       }
10457
10458     case EM_MN10300:
10459     case EM_CYGNUS_MN10300:
10460       {
10461         static Elf_Internal_Sym * saved_sym = NULL;
10462
10463         switch (reloc_type)
10464           {
10465           case 34: /* R_MN10300_ALIGN */
10466             return TRUE;
10467           case 33: /* R_MN10300_SYM_DIFF */
10468             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10469             return TRUE;
10470           case 1: /* R_MN10300_32 */
10471           case 2: /* R_MN10300_16 */
10472             if (saved_sym != NULL)
10473               {
10474                 bfd_vma value;
10475
10476                 value = reloc->r_addend
10477                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10478                      - saved_sym->st_value);
10479
10480                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10481
10482                 saved_sym = NULL;
10483                 return TRUE;
10484               }
10485             break;
10486           default:
10487             if (saved_sym != NULL)
10488               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10489             break;
10490           }
10491         break;
10492       }
10493     }
10494
10495   return FALSE;
10496 }
10497
10498 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10499    DWARF debug sections.  This is a target specific test.  Note - we do not
10500    go through the whole including-target-headers-multiple-times route, (as
10501    we have already done with <elf/h8.h>) because this would become very
10502    messy and even then this function would have to contain target specific
10503    information (the names of the relocs instead of their numeric values).
10504    FIXME: This is not the correct way to solve this problem.  The proper way
10505    is to have target specific reloc sizing and typing functions created by
10506    the reloc-macros.h header, in the same way that it already creates the
10507    reloc naming functions.  */
10508
10509 static bfd_boolean
10510 is_32bit_abs_reloc (unsigned int reloc_type)
10511 {
10512   switch (elf_header.e_machine)
10513     {
10514     case EM_386:
10515     case EM_486:
10516       return reloc_type == 1; /* R_386_32.  */
10517     case EM_68K:
10518       return reloc_type == 1; /* R_68K_32.  */
10519     case EM_860:
10520       return reloc_type == 1; /* R_860_32.  */
10521     case EM_960:
10522       return reloc_type == 2; /* R_960_32.  */
10523     case EM_AARCH64:
10524       return reloc_type == 258; /* R_AARCH64_ABS32 */
10525     case EM_ALPHA:
10526       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10527     case EM_ARC:
10528       return reloc_type == 1; /* R_ARC_32.  */
10529     case EM_ARM:
10530       return reloc_type == 2; /* R_ARM_ABS32 */
10531     case EM_AVR_OLD:
10532     case EM_AVR:
10533       return reloc_type == 1;
10534     case EM_ADAPTEVA_EPIPHANY:
10535       return reloc_type == 3;
10536     case EM_BLACKFIN:
10537       return reloc_type == 0x12; /* R_byte4_data.  */
10538     case EM_CRIS:
10539       return reloc_type == 3; /* R_CRIS_32.  */
10540     case EM_CR16:
10541       return reloc_type == 3; /* R_CR16_NUM32.  */
10542     case EM_CRX:
10543       return reloc_type == 15; /* R_CRX_NUM32.  */
10544     case EM_CYGNUS_FRV:
10545       return reloc_type == 1;
10546     case EM_CYGNUS_D10V:
10547     case EM_D10V:
10548       return reloc_type == 6; /* R_D10V_32.  */
10549     case EM_CYGNUS_D30V:
10550     case EM_D30V:
10551       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10552     case EM_DLX:
10553       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10554     case EM_CYGNUS_FR30:
10555     case EM_FR30:
10556       return reloc_type == 3; /* R_FR30_32.  */
10557     case EM_H8S:
10558     case EM_H8_300:
10559     case EM_H8_300H:
10560       return reloc_type == 1; /* R_H8_DIR32.  */
10561     case EM_IA_64:
10562       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10563     case EM_IP2K_OLD:
10564     case EM_IP2K:
10565       return reloc_type == 2; /* R_IP2K_32.  */
10566     case EM_IQ2000:
10567       return reloc_type == 2; /* R_IQ2000_32.  */
10568     case EM_LATTICEMICO32:
10569       return reloc_type == 3; /* R_LM32_32.  */
10570     case EM_M32C_OLD:
10571     case EM_M32C:
10572       return reloc_type == 3; /* R_M32C_32.  */
10573     case EM_M32R:
10574       return reloc_type == 34; /* R_M32R_32_RELA.  */
10575     case EM_MCORE:
10576       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10577     case EM_CYGNUS_MEP:
10578       return reloc_type == 4; /* R_MEP_32.  */
10579     case EM_METAG:
10580       return reloc_type == 2; /* R_METAG_ADDR32.  */
10581     case EM_MICROBLAZE:
10582       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10583     case EM_MIPS:
10584       return reloc_type == 2; /* R_MIPS_32.  */
10585     case EM_MMIX:
10586       return reloc_type == 4; /* R_MMIX_32.  */
10587     case EM_CYGNUS_MN10200:
10588     case EM_MN10200:
10589       return reloc_type == 1; /* R_MN10200_32.  */
10590     case EM_CYGNUS_MN10300:
10591     case EM_MN10300:
10592       return reloc_type == 1; /* R_MN10300_32.  */
10593     case EM_MOXIE:
10594       return reloc_type == 1; /* R_MOXIE_32.  */
10595     case EM_MSP430_OLD:
10596     case EM_MSP430:
10597       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10598     case EM_MT:
10599       return reloc_type == 2; /* R_MT_32.  */
10600     case EM_NDS32:
10601       return reloc_type == 20; /* R_NDS32_RELA.  */
10602     case EM_ALTERA_NIOS2:
10603       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10604     case EM_NIOS32:
10605       return reloc_type == 1; /* R_NIOS_32.  */
10606     case EM_OR1K:
10607       return reloc_type == 1; /* R_OR1K_32.  */
10608     case EM_PARISC:
10609       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10610               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10611     case EM_PJ:
10612     case EM_PJ_OLD:
10613       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10614     case EM_PPC64:
10615       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10616     case EM_PPC:
10617       return reloc_type == 1; /* R_PPC_ADDR32.  */
10618     case EM_RL78:
10619       return reloc_type == 1; /* R_RL78_DIR32.  */
10620     case EM_RX:
10621       return reloc_type == 1; /* R_RX_DIR32.  */
10622     case EM_S370:
10623       return reloc_type == 1; /* R_I370_ADDR31.  */
10624     case EM_S390_OLD:
10625     case EM_S390:
10626       return reloc_type == 4; /* R_S390_32.  */
10627     case EM_SCORE:
10628       return reloc_type == 8; /* R_SCORE_ABS32.  */
10629     case EM_SH:
10630       return reloc_type == 1; /* R_SH_DIR32.  */
10631     case EM_SPARC32PLUS:
10632     case EM_SPARCV9:
10633     case EM_SPARC:
10634       return reloc_type == 3 /* R_SPARC_32.  */
10635         || reloc_type == 23; /* R_SPARC_UA32.  */
10636     case EM_SPU:
10637       return reloc_type == 6; /* R_SPU_ADDR32 */
10638     case EM_TI_C6000:
10639       return reloc_type == 1; /* R_C6000_ABS32.  */
10640     case EM_TILEGX:
10641       return reloc_type == 2; /* R_TILEGX_32.  */
10642     case EM_TILEPRO:
10643       return reloc_type == 1; /* R_TILEPRO_32.  */
10644     case EM_CYGNUS_V850:
10645     case EM_V850:
10646       return reloc_type == 6; /* R_V850_ABS32.  */
10647     case EM_V800:
10648       return reloc_type == 0x33; /* R_V810_WORD.  */
10649     case EM_VAX:
10650       return reloc_type == 1; /* R_VAX_32.  */
10651     case EM_X86_64:
10652     case EM_L1OM:
10653     case EM_K1OM:
10654       return reloc_type == 10; /* R_X86_64_32.  */
10655     case EM_XC16X:
10656     case EM_C166:
10657       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10658     case EM_XGATE:
10659       return reloc_type == 4; /* R_XGATE_32.  */
10660     case EM_XSTORMY16:
10661       return reloc_type == 1; /* R_XSTROMY16_32.  */
10662     case EM_XTENSA_OLD:
10663     case EM_XTENSA:
10664       return reloc_type == 1; /* R_XTENSA_32.  */
10665     default:
10666       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10667              elf_header.e_machine);
10668       abort ();
10669     }
10670 }
10671
10672 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10673    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10674
10675 static bfd_boolean
10676 is_32bit_pcrel_reloc (unsigned int reloc_type)
10677 {
10678   switch (elf_header.e_machine)
10679     {
10680     case EM_386:
10681     case EM_486:
10682       return reloc_type == 2;  /* R_386_PC32.  */
10683     case EM_68K:
10684       return reloc_type == 4;  /* R_68K_PC32.  */
10685     case EM_AARCH64:
10686       return reloc_type == 261; /* R_AARCH64_PREL32 */
10687     case EM_ADAPTEVA_EPIPHANY:
10688       return reloc_type == 6;
10689     case EM_ALPHA:
10690       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10691     case EM_ARM:
10692       return reloc_type == 3;  /* R_ARM_REL32 */
10693     case EM_MICROBLAZE:
10694       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10695     case EM_OR1K:
10696       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
10697     case EM_PARISC:
10698       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10699     case EM_PPC:
10700       return reloc_type == 26; /* R_PPC_REL32.  */
10701     case EM_PPC64:
10702       return reloc_type == 26; /* R_PPC64_REL32.  */
10703     case EM_S390_OLD:
10704     case EM_S390:
10705       return reloc_type == 5;  /* R_390_PC32.  */
10706     case EM_SH:
10707       return reloc_type == 2;  /* R_SH_REL32.  */
10708     case EM_SPARC32PLUS:
10709     case EM_SPARCV9:
10710     case EM_SPARC:
10711       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10712     case EM_SPU:
10713       return reloc_type == 13; /* R_SPU_REL32.  */
10714     case EM_TILEGX:
10715       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10716     case EM_TILEPRO:
10717       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10718     case EM_X86_64:
10719     case EM_L1OM:
10720     case EM_K1OM:
10721       return reloc_type == 2;  /* R_X86_64_PC32.  */
10722     case EM_XTENSA_OLD:
10723     case EM_XTENSA:
10724       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10725     default:
10726       /* Do not abort or issue an error message here.  Not all targets use
10727          pc-relative 32-bit relocs in their DWARF debug information and we
10728          have already tested for target coverage in is_32bit_abs_reloc.  A
10729          more helpful warning message will be generated by apply_relocations
10730          anyway, so just return.  */
10731       return FALSE;
10732     }
10733 }
10734
10735 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10736    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10737
10738 static bfd_boolean
10739 is_64bit_abs_reloc (unsigned int reloc_type)
10740 {
10741   switch (elf_header.e_machine)
10742     {
10743     case EM_AARCH64:
10744       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10745     case EM_ALPHA:
10746       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10747     case EM_IA_64:
10748       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10749     case EM_PARISC:
10750       return reloc_type == 80; /* R_PARISC_DIR64.  */
10751     case EM_PPC64:
10752       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10753     case EM_SPARC32PLUS:
10754     case EM_SPARCV9:
10755     case EM_SPARC:
10756       return reloc_type == 54; /* R_SPARC_UA64.  */
10757     case EM_X86_64:
10758     case EM_L1OM:
10759     case EM_K1OM:
10760       return reloc_type == 1; /* R_X86_64_64.  */
10761     case EM_S390_OLD:
10762     case EM_S390:
10763       return reloc_type == 22;  /* R_S390_64.  */
10764     case EM_TILEGX:
10765       return reloc_type == 1; /* R_TILEGX_64.  */
10766     case EM_MIPS:
10767       return reloc_type == 18;  /* R_MIPS_64.  */
10768     default:
10769       return FALSE;
10770     }
10771 }
10772
10773 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10774    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10775
10776 static bfd_boolean
10777 is_64bit_pcrel_reloc (unsigned int reloc_type)
10778 {
10779   switch (elf_header.e_machine)
10780     {
10781     case EM_AARCH64:
10782       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10783     case EM_ALPHA:
10784       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10785     case EM_IA_64:
10786       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10787     case EM_PARISC:
10788       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10789     case EM_PPC64:
10790       return reloc_type == 44; /* R_PPC64_REL64.  */
10791     case EM_SPARC32PLUS:
10792     case EM_SPARCV9:
10793     case EM_SPARC:
10794       return reloc_type == 46; /* R_SPARC_DISP64.  */
10795     case EM_X86_64:
10796     case EM_L1OM:
10797     case EM_K1OM:
10798       return reloc_type == 24; /* R_X86_64_PC64.  */
10799     case EM_S390_OLD:
10800     case EM_S390:
10801       return reloc_type == 23;  /* R_S390_PC64.  */
10802     case EM_TILEGX:
10803       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10804     default:
10805       return FALSE;
10806     }
10807 }
10808
10809 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10810    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10811
10812 static bfd_boolean
10813 is_24bit_abs_reloc (unsigned int reloc_type)
10814 {
10815   switch (elf_header.e_machine)
10816     {
10817     case EM_CYGNUS_MN10200:
10818     case EM_MN10200:
10819       return reloc_type == 4; /* R_MN10200_24.  */
10820     default:
10821       return FALSE;
10822     }
10823 }
10824
10825 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10826    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10827
10828 static bfd_boolean
10829 is_16bit_abs_reloc (unsigned int reloc_type)
10830 {
10831   switch (elf_header.e_machine)
10832     {
10833     case EM_AVR_OLD:
10834     case EM_AVR:
10835       return reloc_type == 4; /* R_AVR_16.  */
10836     case EM_ADAPTEVA_EPIPHANY:
10837       return reloc_type == 5;
10838     case EM_CYGNUS_D10V:
10839     case EM_D10V:
10840       return reloc_type == 3; /* R_D10V_16.  */
10841     case EM_H8S:
10842     case EM_H8_300:
10843     case EM_H8_300H:
10844       return reloc_type == R_H8_DIR16;
10845     case EM_IP2K_OLD:
10846     case EM_IP2K:
10847       return reloc_type == 1; /* R_IP2K_16.  */
10848     case EM_M32C_OLD:
10849     case EM_M32C:
10850       return reloc_type == 1; /* R_M32C_16 */
10851     case EM_MSP430:
10852       if (uses_msp430x_relocs ())
10853         return reloc_type == 2; /* R_MSP430_ABS16.  */
10854     case EM_MSP430_OLD:
10855       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10856     case EM_NDS32:
10857       return reloc_type == 19; /* R_NDS32_RELA.  */
10858     case EM_ALTERA_NIOS2:
10859       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10860     case EM_NIOS32:
10861       return reloc_type == 9; /* R_NIOS_16.  */
10862     case EM_OR1K:
10863       return reloc_type == 2; /* R_OR1K_16.  */
10864     case EM_TI_C6000:
10865       return reloc_type == 2; /* R_C6000_ABS16.  */
10866     case EM_XC16X:
10867     case EM_C166:
10868       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10869     case EM_CYGNUS_MN10200:
10870     case EM_MN10200:
10871       return reloc_type == 2; /* R_MN10200_16.  */
10872     case EM_CYGNUS_MN10300:
10873     case EM_MN10300:
10874       return reloc_type == 2; /* R_MN10300_16.  */
10875     case EM_XGATE:
10876       return reloc_type == 3; /* R_XGATE_16.  */
10877     default:
10878       return FALSE;
10879     }
10880 }
10881
10882 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10883    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10884
10885 static bfd_boolean
10886 is_none_reloc (unsigned int reloc_type)
10887 {
10888   switch (elf_header.e_machine)
10889     {
10890     case EM_68K:     /* R_68K_NONE.  */
10891     case EM_386:     /* R_386_NONE.  */
10892     case EM_SPARC32PLUS:
10893     case EM_SPARCV9:
10894     case EM_SPARC:   /* R_SPARC_NONE.  */
10895     case EM_MIPS:    /* R_MIPS_NONE.  */
10896     case EM_PARISC:  /* R_PARISC_NONE.  */
10897     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10898     case EM_ADAPTEVA_EPIPHANY:
10899     case EM_PPC:     /* R_PPC_NONE.  */
10900     case EM_PPC64:   /* R_PPC64_NONE.  */
10901     case EM_ARM:     /* R_ARM_NONE.  */
10902     case EM_IA_64:   /* R_IA64_NONE.  */
10903     case EM_SH:      /* R_SH_NONE.  */
10904     case EM_S390_OLD:
10905     case EM_S390:    /* R_390_NONE.  */
10906     case EM_CRIS:    /* R_CRIS_NONE.  */
10907     case EM_X86_64:  /* R_X86_64_NONE.  */
10908     case EM_L1OM:    /* R_X86_64_NONE.  */
10909     case EM_K1OM:    /* R_X86_64_NONE.  */
10910     case EM_MN10300: /* R_MN10300_NONE.  */
10911     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10912     case EM_M32R:    /* R_M32R_NONE.  */
10913     case EM_TI_C6000:/* R_C6000_NONE.  */
10914     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10915     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10916     case EM_XC16X:
10917     case EM_C166:    /* R_XC16X_NONE.  */
10918     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10919     case EM_NIOS32:  /* R_NIOS_NONE.  */
10920     case EM_OR1K:    /* R_OR1K_NONE. */
10921       return reloc_type == 0;
10922     case EM_AARCH64:
10923       return reloc_type == 0 || reloc_type == 256;
10924     case EM_NDS32:
10925       return (reloc_type == 0       /* R_XTENSA_NONE.  */
10926               || reloc_type == 204  /* R_NDS32_DIFF8.  */
10927               || reloc_type == 205  /* R_NDS32_DIFF16.  */
10928               || reloc_type == 206  /* R_NDS32_DIFF32.  */
10929               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
10930     case EM_XTENSA_OLD:
10931     case EM_XTENSA:
10932       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10933               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10934               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10935               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10936     case EM_METAG:
10937       return reloc_type == 3; /* R_METAG_NONE.  */
10938     }
10939   return FALSE;
10940 }
10941
10942 /* Apply relocations to a section.
10943    Note: So far support has been added only for those relocations
10944    which can be found in debug sections.
10945    FIXME: Add support for more relocations ?  */
10946
10947 static void
10948 apply_relocations (void * file,
10949                    Elf_Internal_Shdr * section,
10950                    unsigned char * start)
10951 {
10952   Elf_Internal_Shdr * relsec;
10953   unsigned char * end = start + section->sh_size;
10954
10955   if (elf_header.e_type != ET_REL)
10956     return;
10957
10958   /* Find the reloc section associated with the section.  */
10959   for (relsec = section_headers;
10960        relsec < section_headers + elf_header.e_shnum;
10961        ++relsec)
10962     {
10963       bfd_boolean is_rela;
10964       unsigned long num_relocs;
10965       Elf_Internal_Rela * relocs;
10966       Elf_Internal_Rela * rp;
10967       Elf_Internal_Shdr * symsec;
10968       Elf_Internal_Sym * symtab;
10969       unsigned long num_syms;
10970       Elf_Internal_Sym * sym;
10971
10972       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10973           || relsec->sh_info >= elf_header.e_shnum
10974           || section_headers + relsec->sh_info != section
10975           || relsec->sh_size == 0
10976           || relsec->sh_link >= elf_header.e_shnum)
10977         continue;
10978
10979       is_rela = relsec->sh_type == SHT_RELA;
10980
10981       if (is_rela)
10982         {
10983           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10984                                   relsec->sh_size, & relocs, & num_relocs))
10985             return;
10986         }
10987       else
10988         {
10989           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10990                                  relsec->sh_size, & relocs, & num_relocs))
10991             return;
10992         }
10993
10994       /* SH uses RELA but uses in place value instead of the addend field.  */
10995       if (elf_header.e_machine == EM_SH)
10996         is_rela = FALSE;
10997
10998       symsec = section_headers + relsec->sh_link;
10999       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11000
11001       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11002         {
11003           bfd_vma         addend;
11004           unsigned int    reloc_type;
11005           unsigned int    reloc_size;
11006           unsigned char * rloc;
11007           unsigned long   sym_index;
11008
11009           reloc_type = get_reloc_type (rp->r_info);
11010
11011           if (target_specific_reloc_handling (rp, start, symtab))
11012             continue;
11013           else if (is_none_reloc (reloc_type))
11014             continue;
11015           else if (is_32bit_abs_reloc (reloc_type)
11016                    || is_32bit_pcrel_reloc (reloc_type))
11017             reloc_size = 4;
11018           else if (is_64bit_abs_reloc (reloc_type)
11019                    || is_64bit_pcrel_reloc (reloc_type))
11020             reloc_size = 8;
11021           else if (is_24bit_abs_reloc (reloc_type))
11022             reloc_size = 3;
11023           else if (is_16bit_abs_reloc (reloc_type))
11024             reloc_size = 2;
11025           else
11026             {
11027               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11028                     reloc_type, SECTION_NAME (section));
11029               continue;
11030             }
11031
11032           rloc = start + rp->r_offset;
11033           if ((rloc + reloc_size) > end || (rloc < start))
11034             {
11035               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11036                     (unsigned long) rp->r_offset,
11037                     SECTION_NAME (section));
11038               continue;
11039             }
11040
11041           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11042           if (sym_index >= num_syms)
11043             {
11044               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11045                     sym_index, SECTION_NAME (section));
11046               continue;
11047             }
11048           sym = symtab + sym_index;
11049
11050           /* If the reloc has a symbol associated with it,
11051              make sure that it is of an appropriate type.
11052
11053              Relocations against symbols without type can happen.
11054              Gcc -feliminate-dwarf2-dups may generate symbols
11055              without type for debug info.
11056
11057              Icc generates relocations against function symbols
11058              instead of local labels.
11059
11060              Relocations against object symbols can happen, eg when
11061              referencing a global array.  For an example of this see
11062              the _clz.o binary in libgcc.a.  */
11063           if (sym != symtab
11064               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11065             {
11066               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11067                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11068                     (long int)(rp - relocs),
11069                     SECTION_NAME (relsec));
11070               continue;
11071             }
11072
11073           addend = 0;
11074           if (is_rela)
11075             addend += rp->r_addend;
11076           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11077              partial_inplace.  */
11078           if (!is_rela
11079               || (elf_header.e_machine == EM_XTENSA
11080                   && reloc_type == 1)
11081               || ((elf_header.e_machine == EM_PJ
11082                    || elf_header.e_machine == EM_PJ_OLD)
11083                   && reloc_type == 1)
11084               || ((elf_header.e_machine == EM_D30V
11085                    || elf_header.e_machine == EM_CYGNUS_D30V)
11086                   && reloc_type == 12))
11087             addend += byte_get (rloc, reloc_size);
11088
11089           if (is_32bit_pcrel_reloc (reloc_type)
11090               || is_64bit_pcrel_reloc (reloc_type))
11091             {
11092               /* On HPPA, all pc-relative relocations are biased by 8.  */
11093               if (elf_header.e_machine == EM_PARISC)
11094                 addend -= 8;
11095               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11096                         reloc_size);
11097             }
11098           else
11099             byte_put (rloc, addend + sym->st_value, reloc_size);
11100         }
11101
11102       free (symtab);
11103       free (relocs);
11104       break;
11105     }
11106 }
11107
11108 #ifdef SUPPORT_DISASSEMBLY
11109 static int
11110 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11111 {
11112   printf (_("\nAssembly dump of section %s\n"),
11113           SECTION_NAME (section));
11114
11115   /* XXX -- to be done --- XXX */
11116
11117   return 1;
11118 }
11119 #endif
11120
11121 /* Reads in the contents of SECTION from FILE, returning a pointer
11122    to a malloc'ed buffer or NULL if something went wrong.  */
11123
11124 static char *
11125 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11126 {
11127   bfd_size_type num_bytes;
11128
11129   num_bytes = section->sh_size;
11130
11131   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11132     {
11133       printf (_("\nSection '%s' has no data to dump.\n"),
11134               SECTION_NAME (section));
11135       return NULL;
11136     }
11137
11138   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11139                              _("section contents"));
11140 }
11141
11142
11143 static void
11144 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11145 {
11146   Elf_Internal_Shdr * relsec;
11147   bfd_size_type num_bytes;
11148   char * data;
11149   char * end;
11150   char * start;
11151   char * name = SECTION_NAME (section);
11152   bfd_boolean some_strings_shown;
11153
11154   start = get_section_contents (section, file);
11155   if (start == NULL)
11156     return;
11157
11158   printf (_("\nString dump of section '%s':\n"), name);
11159
11160   /* If the section being dumped has relocations against it the user might
11161      be expecting these relocations to have been applied.  Check for this
11162      case and issue a warning message in order to avoid confusion.
11163      FIXME: Maybe we ought to have an option that dumps a section with
11164      relocs applied ?  */
11165   for (relsec = section_headers;
11166        relsec < section_headers + elf_header.e_shnum;
11167        ++relsec)
11168     {
11169       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11170           || relsec->sh_info >= elf_header.e_shnum
11171           || section_headers + relsec->sh_info != section
11172           || relsec->sh_size == 0
11173           || relsec->sh_link >= elf_header.e_shnum)
11174         continue;
11175
11176       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11177       break;
11178     }
11179
11180   num_bytes = section->sh_size;
11181   data = start;
11182   end  = start + num_bytes;
11183   some_strings_shown = FALSE;
11184
11185   while (data < end)
11186     {
11187       while (!ISPRINT (* data))
11188         if (++ data >= end)
11189           break;
11190
11191       if (data < end)
11192         {
11193 #ifndef __MSVCRT__
11194           /* PR 11128: Use two separate invocations in order to work
11195              around bugs in the Solaris 8 implementation of printf.  */
11196           printf ("  [%6tx]  ", data - start);
11197           printf ("%s\n", data);
11198 #else
11199           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
11200 #endif
11201           data += strlen (data);
11202           some_strings_shown = TRUE;
11203         }
11204     }
11205
11206   if (! some_strings_shown)
11207     printf (_("  No strings found in this section."));
11208
11209   free (start);
11210
11211   putchar ('\n');
11212 }
11213
11214 static void
11215 dump_section_as_bytes (Elf_Internal_Shdr * section,
11216                        FILE * file,
11217                        bfd_boolean relocate)
11218 {
11219   Elf_Internal_Shdr * relsec;
11220   bfd_size_type bytes;
11221   bfd_vma addr;
11222   unsigned char * data;
11223   unsigned char * start;
11224
11225   start = (unsigned char *) get_section_contents (section, file);
11226   if (start == NULL)
11227     return;
11228
11229   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11230
11231   if (relocate)
11232     {
11233       apply_relocations (file, section, start);
11234     }
11235   else
11236     {
11237       /* If the section being dumped has relocations against it the user might
11238          be expecting these relocations to have been applied.  Check for this
11239          case and issue a warning message in order to avoid confusion.
11240          FIXME: Maybe we ought to have an option that dumps a section with
11241          relocs applied ?  */
11242       for (relsec = section_headers;
11243            relsec < section_headers + elf_header.e_shnum;
11244            ++relsec)
11245         {
11246           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11247               || relsec->sh_info >= elf_header.e_shnum
11248               || section_headers + relsec->sh_info != section
11249               || relsec->sh_size == 0
11250               || relsec->sh_link >= elf_header.e_shnum)
11251             continue;
11252
11253           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11254           break;
11255         }
11256     }
11257
11258   addr = section->sh_addr;
11259   bytes = section->sh_size;
11260   data = start;
11261
11262   while (bytes)
11263     {
11264       int j;
11265       int k;
11266       int lbytes;
11267
11268       lbytes = (bytes > 16 ? 16 : bytes);
11269
11270       printf ("  0x%8.8lx ", (unsigned long) addr);
11271
11272       for (j = 0; j < 16; j++)
11273         {
11274           if (j < lbytes)
11275             printf ("%2.2x", data[j]);
11276           else
11277             printf ("  ");
11278
11279           if ((j & 3) == 3)
11280             printf (" ");
11281         }
11282
11283       for (j = 0; j < lbytes; j++)
11284         {
11285           k = data[j];
11286           if (k >= ' ' && k < 0x7f)
11287             printf ("%c", k);
11288           else
11289             printf (".");
11290         }
11291
11292       putchar ('\n');
11293
11294       data  += lbytes;
11295       addr  += lbytes;
11296       bytes -= lbytes;
11297     }
11298
11299   free (start);
11300
11301   putchar ('\n');
11302 }
11303
11304 /* Uncompresses a section that was compressed using zlib, in place.  */
11305
11306 static int
11307 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11308                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11309 {
11310 #ifndef HAVE_ZLIB_H
11311   return FALSE;
11312 #else
11313   dwarf_size_type compressed_size = *size;
11314   unsigned char * compressed_buffer = *buffer;
11315   dwarf_size_type uncompressed_size;
11316   unsigned char * uncompressed_buffer;
11317   z_stream strm;
11318   int rc;
11319   dwarf_size_type header_size = 12;
11320
11321   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11322      by the uncompressed section size, 8 bytes in big-endian order.  */
11323   if (compressed_size < header_size
11324       || ! streq ((char *) compressed_buffer, "ZLIB"))
11325     return 0;
11326
11327   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11328   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11329   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11330   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11331   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11332   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11333   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11334   uncompressed_size += compressed_buffer[11];
11335
11336   /* It is possible the section consists of several compressed
11337      buffers concatenated together, so we uncompress in a loop.  */
11338   strm.zalloc = NULL;
11339   strm.zfree = NULL;
11340   strm.opaque = NULL;
11341   strm.avail_in = compressed_size - header_size;
11342   strm.next_in = (Bytef *) compressed_buffer + header_size;
11343   strm.avail_out = uncompressed_size;
11344   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11345
11346   rc = inflateInit (& strm);
11347   while (strm.avail_in > 0)
11348     {
11349       if (rc != Z_OK)
11350         goto fail;
11351       strm.next_out = ((Bytef *) uncompressed_buffer
11352                        + (uncompressed_size - strm.avail_out));
11353       rc = inflate (&strm, Z_FINISH);
11354       if (rc != Z_STREAM_END)
11355         goto fail;
11356       rc = inflateReset (& strm);
11357     }
11358   rc = inflateEnd (& strm);
11359   if (rc != Z_OK
11360       || strm.avail_out != 0)
11361     goto fail;
11362
11363   free (compressed_buffer);
11364   *buffer = uncompressed_buffer;
11365   *size = uncompressed_size;
11366   return 1;
11367
11368  fail:
11369   free (uncompressed_buffer);
11370   /* Indicate decompression failure.  */
11371   *buffer = NULL;
11372   return 0;
11373 #endif  /* HAVE_ZLIB_H */
11374 }
11375
11376 static int
11377 load_specific_debug_section (enum dwarf_section_display_enum debug,
11378                              Elf_Internal_Shdr * sec, void * file)
11379 {
11380   struct dwarf_section * section = &debug_displays [debug].section;
11381   char buf [64];
11382
11383   /* If it is already loaded, do nothing.  */
11384   if (section->start != NULL)
11385     return 1;
11386
11387   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11388   section->address = sec->sh_addr;
11389   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11390                                                sec->sh_offset, 1,
11391                                                sec->sh_size, buf);
11392   if (section->start == NULL)
11393     section->size = 0;
11394   else
11395     {
11396       section->size = sec->sh_size;
11397       if (uncompress_section_contents (&section->start, &section->size))
11398         sec->sh_size = section->size;
11399     }
11400
11401   if (section->start == NULL)
11402     return 0;
11403
11404   if (debug_displays [debug].relocate)
11405     apply_relocations ((FILE *) file, sec, section->start);
11406
11407   return 1;
11408 }
11409
11410 /* If this is not NULL, load_debug_section will only look for sections
11411    within the list of sections given here.  */
11412 unsigned int *section_subset = NULL;
11413
11414 int
11415 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11416 {
11417   struct dwarf_section * section = &debug_displays [debug].section;
11418   Elf_Internal_Shdr * sec;
11419
11420   /* Locate the debug section.  */
11421   sec = find_section_in_set (section->uncompressed_name, section_subset);
11422   if (sec != NULL)
11423     section->name = section->uncompressed_name;
11424   else
11425     {
11426       sec = find_section_in_set (section->compressed_name, section_subset);
11427       if (sec != NULL)
11428         section->name = section->compressed_name;
11429     }
11430   if (sec == NULL)
11431     return 0;
11432
11433   /* If we're loading from a subset of sections, and we've loaded
11434      a section matching this name before, it's likely that it's a
11435      different one.  */
11436   if (section_subset != NULL)
11437     free_debug_section (debug);
11438
11439   return load_specific_debug_section (debug, sec, (FILE *) file);
11440 }
11441
11442 void
11443 free_debug_section (enum dwarf_section_display_enum debug)
11444 {
11445   struct dwarf_section * section = &debug_displays [debug].section;
11446
11447   if (section->start == NULL)
11448     return;
11449
11450   free ((char *) section->start);
11451   section->start = NULL;
11452   section->address = 0;
11453   section->size = 0;
11454 }
11455
11456 static int
11457 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11458 {
11459   char * name = SECTION_NAME (section);
11460   bfd_size_type length;
11461   int result = 1;
11462   int i;
11463
11464   length = section->sh_size;
11465   if (length == 0)
11466     {
11467       printf (_("\nSection '%s' has no debugging data.\n"), name);
11468       return 0;
11469     }
11470   if (section->sh_type == SHT_NOBITS)
11471     {
11472       /* There is no point in dumping the contents of a debugging section
11473          which has the NOBITS type - the bits in the file will be random.
11474          This can happen when a file containing a .eh_frame section is
11475          stripped with the --only-keep-debug command line option.  */
11476       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11477       return 0;
11478     }
11479
11480   if (const_strneq (name, ".gnu.linkonce.wi."))
11481     name = ".debug_info";
11482
11483   /* See if we know how to display the contents of this section.  */
11484   for (i = 0; i < max; i++)
11485     if (streq (debug_displays[i].section.uncompressed_name, name)
11486         || (i == line && const_strneq (name, ".debug_line."))
11487         || streq (debug_displays[i].section.compressed_name, name))
11488       {
11489         struct dwarf_section * sec = &debug_displays [i].section;
11490         int secondary = (section != find_section (name));
11491
11492         if (secondary)
11493           free_debug_section ((enum dwarf_section_display_enum) i);
11494
11495         if (i == line && const_strneq (name, ".debug_line."))
11496           sec->name = name;
11497         else if (streq (sec->uncompressed_name, name))
11498           sec->name = sec->uncompressed_name;
11499         else
11500           sec->name = sec->compressed_name;
11501         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11502                                          section, file))
11503           {
11504             /* If this debug section is part of a CU/TU set in a .dwp file,
11505                restrict load_debug_section to the sections in that set.  */
11506             section_subset = find_cu_tu_set (file, shndx);
11507
11508             result &= debug_displays[i].display (sec, file);
11509
11510             section_subset = NULL;
11511
11512             if (secondary || (i != info && i != abbrev))
11513               free_debug_section ((enum dwarf_section_display_enum) i);
11514           }
11515
11516         break;
11517       }
11518
11519   if (i == max)
11520     {
11521       printf (_("Unrecognized debug section: %s\n"), name);
11522       result = 0;
11523     }
11524
11525   return result;
11526 }
11527
11528 /* Set DUMP_SECTS for all sections where dumps were requested
11529    based on section name.  */
11530
11531 static void
11532 initialise_dumps_byname (void)
11533 {
11534   struct dump_list_entry * cur;
11535
11536   for (cur = dump_sects_byname; cur; cur = cur->next)
11537     {
11538       unsigned int i;
11539       int any;
11540
11541       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11542         if (streq (SECTION_NAME (section_headers + i), cur->name))
11543           {
11544             request_dump_bynumber (i, cur->type);
11545             any = 1;
11546           }
11547
11548       if (!any)
11549         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11550               cur->name);
11551     }
11552 }
11553
11554 static void
11555 process_section_contents (FILE * file)
11556 {
11557   Elf_Internal_Shdr * section;
11558   unsigned int i;
11559
11560   if (! do_dump)
11561     return;
11562
11563   initialise_dumps_byname ();
11564
11565   for (i = 0, section = section_headers;
11566        i < elf_header.e_shnum && i < num_dump_sects;
11567        i++, section++)
11568     {
11569 #ifdef SUPPORT_DISASSEMBLY
11570       if (dump_sects[i] & DISASS_DUMP)
11571         disassemble_section (section, file);
11572 #endif
11573       if (dump_sects[i] & HEX_DUMP)
11574         dump_section_as_bytes (section, file, FALSE);
11575
11576       if (dump_sects[i] & RELOC_DUMP)
11577         dump_section_as_bytes (section, file, TRUE);
11578
11579       if (dump_sects[i] & STRING_DUMP)
11580         dump_section_as_strings (section, file);
11581
11582       if (dump_sects[i] & DEBUG_DUMP)
11583         display_debug_section (i, section, file);
11584     }
11585
11586   /* Check to see if the user requested a
11587      dump of a section that does not exist.  */
11588   while (i++ < num_dump_sects)
11589     if (dump_sects[i])
11590       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11591 }
11592
11593 static void
11594 process_mips_fpe_exception (int mask)
11595 {
11596   if (mask)
11597     {
11598       int first = 1;
11599       if (mask & OEX_FPU_INEX)
11600         fputs ("INEX", stdout), first = 0;
11601       if (mask & OEX_FPU_UFLO)
11602         printf ("%sUFLO", first ? "" : "|"), first = 0;
11603       if (mask & OEX_FPU_OFLO)
11604         printf ("%sOFLO", first ? "" : "|"), first = 0;
11605       if (mask & OEX_FPU_DIV0)
11606         printf ("%sDIV0", first ? "" : "|"), first = 0;
11607       if (mask & OEX_FPU_INVAL)
11608         printf ("%sINVAL", first ? "" : "|");
11609     }
11610   else
11611     fputs ("0", stdout);
11612 }
11613
11614 /* Display's the value of TAG at location P.  If TAG is
11615    greater than 0 it is assumed to be an unknown tag, and
11616    a message is printed to this effect.  Otherwise it is
11617    assumed that a message has already been printed.
11618
11619    If the bottom bit of TAG is set it assumed to have a
11620    string value, otherwise it is assumed to have an integer
11621    value.
11622
11623    Returns an updated P pointing to the first unread byte
11624    beyond the end of TAG's value.
11625
11626    Reads at or beyond END will not be made.  */
11627
11628 static unsigned char *
11629 display_tag_value (int tag,
11630                    unsigned char * p,
11631                    const unsigned char * const end)
11632 {
11633   unsigned long val;
11634
11635   if (tag > 0)
11636     printf ("  Tag_unknown_%d: ", tag);
11637
11638   if (p >= end)
11639     {
11640       warn (_("corrupt tag\n"));
11641     }
11642   else if (tag & 1)
11643     {
11644       /* FIXME: we could read beyond END here.  */
11645       printf ("\"%s\"\n", p);
11646       p += strlen ((char *) p) + 1;
11647     }
11648   else
11649     {
11650       unsigned int len;
11651
11652       val = read_uleb128 (p, &len, end);
11653       p += len;
11654       printf ("%ld (0x%lx)\n", val, val);
11655     }
11656
11657   return p;
11658 }
11659
11660 /* ARM EABI attributes section.  */
11661 typedef struct
11662 {
11663   unsigned int tag;
11664   const char * name;
11665   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11666   unsigned int type;
11667   const char ** table;
11668 } arm_attr_public_tag;
11669
11670 static const char * arm_attr_tag_CPU_arch[] =
11671   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11672    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11673 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11674 static const char * arm_attr_tag_THUMB_ISA_use[] =
11675   {"No", "Thumb-1", "Thumb-2"};
11676 static const char * arm_attr_tag_FP_arch[] =
11677   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11678    "FP for ARMv8"};
11679 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11680 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11681   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11682 static const char * arm_attr_tag_PCS_config[] =
11683   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11684    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11685 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11686   {"V6", "SB", "TLS", "Unused"};
11687 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11688   {"Absolute", "PC-relative", "SB-relative", "None"};
11689 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11690   {"Absolute", "PC-relative", "None"};
11691 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11692   {"None", "direct", "GOT-indirect"};
11693 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11694   {"None", "??? 1", "2", "??? 3", "4"};
11695 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11696 static const char * arm_attr_tag_ABI_FP_denormal[] =
11697   {"Unused", "Needed", "Sign only"};
11698 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11699 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11700 static const char * arm_attr_tag_ABI_FP_number_model[] =
11701   {"Unused", "Finite", "RTABI", "IEEE 754"};
11702 static const char * arm_attr_tag_ABI_enum_size[] =
11703   {"Unused", "small", "int", "forced to int"};
11704 static const char * arm_attr_tag_ABI_HardFP_use[] =
11705   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11706 static const char * arm_attr_tag_ABI_VFP_args[] =
11707   {"AAPCS", "VFP registers", "custom"};
11708 static const char * arm_attr_tag_ABI_WMMX_args[] =
11709   {"AAPCS", "WMMX registers", "custom"};
11710 static const char * arm_attr_tag_ABI_optimization_goals[] =
11711   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11712     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11713 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11714   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11715     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11716 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11717 static const char * arm_attr_tag_FP_HP_extension[] =
11718   {"Not Allowed", "Allowed"};
11719 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11720   {"None", "IEEE 754", "Alternative Format"};
11721 static const char * arm_attr_tag_MPextension_use[] =
11722   {"Not Allowed", "Allowed"};
11723 static const char * arm_attr_tag_DIV_use[] =
11724   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11725     "Allowed in v7-A with integer division extension"};
11726 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11727 static const char * arm_attr_tag_Virtualization_use[] =
11728   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11729     "TrustZone and Virtualization Extensions"};
11730 static const char * arm_attr_tag_MPextension_use_legacy[] =
11731   {"Not Allowed", "Allowed"};
11732
11733 #define LOOKUP(id, name) \
11734   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11735 static arm_attr_public_tag arm_attr_public_tags[] =
11736 {
11737   {4, "CPU_raw_name", 1, NULL},
11738   {5, "CPU_name", 1, NULL},
11739   LOOKUP(6, CPU_arch),
11740   {7, "CPU_arch_profile", 0, NULL},
11741   LOOKUP(8, ARM_ISA_use),
11742   LOOKUP(9, THUMB_ISA_use),
11743   LOOKUP(10, FP_arch),
11744   LOOKUP(11, WMMX_arch),
11745   LOOKUP(12, Advanced_SIMD_arch),
11746   LOOKUP(13, PCS_config),
11747   LOOKUP(14, ABI_PCS_R9_use),
11748   LOOKUP(15, ABI_PCS_RW_data),
11749   LOOKUP(16, ABI_PCS_RO_data),
11750   LOOKUP(17, ABI_PCS_GOT_use),
11751   LOOKUP(18, ABI_PCS_wchar_t),
11752   LOOKUP(19, ABI_FP_rounding),
11753   LOOKUP(20, ABI_FP_denormal),
11754   LOOKUP(21, ABI_FP_exceptions),
11755   LOOKUP(22, ABI_FP_user_exceptions),
11756   LOOKUP(23, ABI_FP_number_model),
11757   {24, "ABI_align_needed", 0, NULL},
11758   {25, "ABI_align_preserved", 0, NULL},
11759   LOOKUP(26, ABI_enum_size),
11760   LOOKUP(27, ABI_HardFP_use),
11761   LOOKUP(28, ABI_VFP_args),
11762   LOOKUP(29, ABI_WMMX_args),
11763   LOOKUP(30, ABI_optimization_goals),
11764   LOOKUP(31, ABI_FP_optimization_goals),
11765   {32, "compatibility", 0, NULL},
11766   LOOKUP(34, CPU_unaligned_access),
11767   LOOKUP(36, FP_HP_extension),
11768   LOOKUP(38, ABI_FP_16bit_format),
11769   LOOKUP(42, MPextension_use),
11770   LOOKUP(44, DIV_use),
11771   {64, "nodefaults", 0, NULL},
11772   {65, "also_compatible_with", 0, NULL},
11773   LOOKUP(66, T2EE_use),
11774   {67, "conformance", 1, NULL},
11775   LOOKUP(68, Virtualization_use),
11776   LOOKUP(70, MPextension_use_legacy)
11777 };
11778 #undef LOOKUP
11779
11780 static unsigned char *
11781 display_arm_attribute (unsigned char * p,
11782                        const unsigned char * const end)
11783 {
11784   unsigned int tag;
11785   unsigned int len;
11786   unsigned int val;
11787   arm_attr_public_tag * attr;
11788   unsigned i;
11789   unsigned int type;
11790
11791   tag = read_uleb128 (p, &len, end);
11792   p += len;
11793   attr = NULL;
11794   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11795     {
11796       if (arm_attr_public_tags[i].tag == tag)
11797         {
11798           attr = &arm_attr_public_tags[i];
11799           break;
11800         }
11801     }
11802
11803   if (attr)
11804     {
11805       printf ("  Tag_%s: ", attr->name);
11806       switch (attr->type)
11807         {
11808         case 0:
11809           switch (tag)
11810             {
11811             case 7: /* Tag_CPU_arch_profile.  */
11812               val = read_uleb128 (p, &len, end);
11813               p += len;
11814               switch (val)
11815                 {
11816                 case 0: printf (_("None\n")); break;
11817                 case 'A': printf (_("Application\n")); break;
11818                 case 'R': printf (_("Realtime\n")); break;
11819                 case 'M': printf (_("Microcontroller\n")); break;
11820                 case 'S': printf (_("Application or Realtime\n")); break;
11821                 default: printf ("??? (%d)\n", val); break;
11822                 }
11823               break;
11824
11825             case 24: /* Tag_align_needed.  */
11826               val = read_uleb128 (p, &len, end);
11827               p += len;
11828               switch (val)
11829                 {
11830                 case 0: printf (_("None\n")); break;
11831                 case 1: printf (_("8-byte\n")); break;
11832                 case 2: printf (_("4-byte\n")); break;
11833                 case 3: printf ("??? 3\n"); break;
11834                 default:
11835                   if (val <= 12)
11836                     printf (_("8-byte and up to %d-byte extended\n"),
11837                             1 << val);
11838                   else
11839                     printf ("??? (%d)\n", val);
11840                   break;
11841                 }
11842               break;
11843
11844             case 25: /* Tag_align_preserved.  */
11845               val = read_uleb128 (p, &len, end);
11846               p += len;
11847               switch (val)
11848                 {
11849                 case 0: printf (_("None\n")); break;
11850                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11851                 case 2: printf (_("8-byte\n")); break;
11852                 case 3: printf ("??? 3\n"); break;
11853                 default:
11854                   if (val <= 12)
11855                     printf (_("8-byte and up to %d-byte extended\n"),
11856                             1 << val);
11857                   else
11858                     printf ("??? (%d)\n", val);
11859                   break;
11860                 }
11861               break;
11862
11863             case 32: /* Tag_compatibility.  */
11864               val = read_uleb128 (p, &len, end);
11865               p += len;
11866               printf (_("flag = %d, vendor = %s\n"), val, p);
11867               p += strlen ((char *) p) + 1;
11868               break;
11869
11870             case 64: /* Tag_nodefaults.  */
11871               p++;
11872               printf (_("True\n"));
11873               break;
11874
11875             case 65: /* Tag_also_compatible_with.  */
11876               val = read_uleb128 (p, &len, end);
11877               p += len;
11878               if (val == 6 /* Tag_CPU_arch.  */)
11879                 {
11880                   val = read_uleb128 (p, &len, end);
11881                   p += len;
11882                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11883                     printf ("??? (%d)\n", val);
11884                   else
11885                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11886                 }
11887               else
11888                 printf ("???\n");
11889               while (*(p++) != '\0' /* NUL terminator.  */);
11890               break;
11891
11892             default:
11893               abort ();
11894             }
11895           return p;
11896
11897         case 1:
11898           return display_tag_value (-1, p, end);
11899         case 2:
11900           return display_tag_value (0, p, end);
11901
11902         default:
11903           assert (attr->type & 0x80);
11904           val = read_uleb128 (p, &len, end);
11905           p += len;
11906           type = attr->type & 0x7f;
11907           if (val >= type)
11908             printf ("??? (%d)\n", val);
11909           else
11910             printf ("%s\n", attr->table[val]);
11911           return p;
11912         }
11913     }
11914
11915   return display_tag_value (tag, p, end);
11916 }
11917
11918 static unsigned char *
11919 display_gnu_attribute (unsigned char * p,
11920                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11921                        const unsigned char * const end)
11922 {
11923   int tag;
11924   unsigned int len;
11925   int val;
11926
11927   tag = read_uleb128 (p, &len, end);
11928   p += len;
11929
11930   /* Tag_compatibility is the only generic GNU attribute defined at
11931      present.  */
11932   if (tag == 32)
11933     {
11934       val = read_uleb128 (p, &len, end);
11935       p += len;
11936       if (p == end)
11937         {
11938           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11939           warn (_("corrupt vendor attribute\n"));
11940         }
11941       else
11942         {
11943           printf (_("flag = %d, vendor = %s\n"), val, p);
11944           p += strlen ((char *) p) + 1;
11945         }
11946       return p;
11947     }
11948
11949   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11950     return display_proc_gnu_attribute (p, tag, end);
11951
11952   return display_tag_value (tag, p, end);
11953 }
11954
11955 static unsigned char *
11956 display_power_gnu_attribute (unsigned char * p,
11957                              int tag,
11958                              const unsigned char * const end)
11959 {
11960   unsigned int len;
11961   int val;
11962
11963   if (tag == Tag_GNU_Power_ABI_FP)
11964     {
11965       val = read_uleb128 (p, &len, end);
11966       p += len;
11967       printf ("  Tag_GNU_Power_ABI_FP: ");
11968
11969       switch (val)
11970         {
11971         case 0:
11972           printf (_("Hard or soft float\n"));
11973           break;
11974         case 1:
11975           printf (_("Hard float\n"));
11976           break;
11977         case 2:
11978           printf (_("Soft float\n"));
11979           break;
11980         case 3:
11981           printf (_("Single-precision hard float\n"));
11982           break;
11983         default:
11984           printf ("??? (%d)\n", val);
11985           break;
11986         }
11987       return p;
11988    }
11989
11990   if (tag == Tag_GNU_Power_ABI_Vector)
11991     {
11992       val = read_uleb128 (p, &len, end);
11993       p += len;
11994       printf ("  Tag_GNU_Power_ABI_Vector: ");
11995       switch (val)
11996         {
11997         case 0:
11998           printf (_("Any\n"));
11999           break;
12000         case 1:
12001           printf (_("Generic\n"));
12002           break;
12003         case 2:
12004           printf ("AltiVec\n");
12005           break;
12006         case 3:
12007           printf ("SPE\n");
12008           break;
12009         default:
12010           printf ("??? (%d)\n", val);
12011           break;
12012         }
12013       return p;
12014    }
12015
12016   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12017     {
12018       if (p == end)
12019         {
12020           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
12021           return p;
12022         }
12023
12024       val = read_uleb128 (p, &len, end);
12025       p += len;
12026       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12027       switch (val)
12028        {
12029        case 0:
12030          printf (_("Any\n"));
12031          break;
12032        case 1:
12033          printf ("r3/r4\n");
12034          break;
12035        case 2:
12036          printf (_("Memory\n"));
12037          break;
12038        default:
12039          printf ("??? (%d)\n", val);
12040          break;
12041        }
12042       return p;
12043     }
12044
12045   return display_tag_value (tag & 1, p, end);
12046 }
12047
12048 static void
12049 display_sparc_hwcaps (int mask)
12050 {
12051   if (mask)
12052     {
12053       int first = 1;
12054       if (mask & ELF_SPARC_HWCAP_MUL32)
12055         fputs ("mul32", stdout), first = 0;
12056       if (mask & ELF_SPARC_HWCAP_DIV32)
12057         printf ("%sdiv32", first ? "" : "|"), first = 0;
12058       if (mask & ELF_SPARC_HWCAP_FSMULD)
12059         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12060       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12061         printf ("%sv8plus", first ? "" : "|"), first = 0;
12062       if (mask & ELF_SPARC_HWCAP_POPC)
12063         printf ("%spopc", first ? "" : "|"), first = 0;
12064       if (mask & ELF_SPARC_HWCAP_VIS)
12065         printf ("%svis", first ? "" : "|"), first = 0;
12066       if (mask & ELF_SPARC_HWCAP_VIS2)
12067         printf ("%svis2", first ? "" : "|"), first = 0;
12068       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12069         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12070       if (mask & ELF_SPARC_HWCAP_FMAF)
12071         printf ("%sfmaf", first ? "" : "|"), first = 0;
12072       if (mask & ELF_SPARC_HWCAP_VIS3)
12073         printf ("%svis3", first ? "" : "|"), first = 0;
12074       if (mask & ELF_SPARC_HWCAP_HPC)
12075         printf ("%shpc", first ? "" : "|"), first = 0;
12076       if (mask & ELF_SPARC_HWCAP_RANDOM)
12077         printf ("%srandom", first ? "" : "|"), first = 0;
12078       if (mask & ELF_SPARC_HWCAP_TRANS)
12079         printf ("%strans", first ? "" : "|"), first = 0;
12080       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12081         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12082       if (mask & ELF_SPARC_HWCAP_IMA)
12083         printf ("%sima", first ? "" : "|"), first = 0;
12084       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12085         printf ("%scspare", first ? "" : "|"), first = 0;
12086     }
12087   else
12088     fputc('0', stdout);
12089   fputc('\n', stdout);
12090 }
12091
12092 static void
12093 display_sparc_hwcaps2 (int mask)
12094 {
12095   if (mask)
12096     {
12097       int first = 1;
12098       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12099         fputs ("fjathplus", stdout), first = 0;
12100       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12101         printf ("%svis3b", first ? "" : "|"), first = 0;
12102       if (mask & ELF_SPARC_HWCAP2_ADP)
12103         printf ("%sadp", first ? "" : "|"), first = 0;
12104       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12105         printf ("%ssparc5", first ? "" : "|"), first = 0;
12106       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12107         printf ("%smwait", first ? "" : "|"), first = 0;
12108       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12109         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12110       if (mask & ELF_SPARC_HWCAP2_XMONT)
12111         printf ("%sxmont2", first ? "" : "|"), first = 0;
12112       if (mask & ELF_SPARC_HWCAP2_NSEC)
12113         printf ("%snsec", first ? "" : "|"), first = 0;
12114       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12115         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12116       if (mask & ELF_SPARC_HWCAP2_FJDES)
12117         printf ("%sfjdes", first ? "" : "|"), first = 0;
12118       if (mask & ELF_SPARC_HWCAP2_FJAES)
12119         printf ("%sfjaes", first ? "" : "|"), first = 0;
12120     }
12121   else
12122     fputc('0', stdout);
12123   fputc('\n', stdout);
12124 }
12125
12126 static unsigned char *
12127 display_sparc_gnu_attribute (unsigned char * p,
12128                              int tag,
12129                              const unsigned char * const end)
12130 {
12131   unsigned int len;
12132   int val;
12133
12134   if (tag == Tag_GNU_Sparc_HWCAPS)
12135     {
12136       val = read_uleb128 (p, &len, end);
12137       p += len;
12138       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12139       display_sparc_hwcaps (val);
12140       return p;
12141     }
12142   if (tag == Tag_GNU_Sparc_HWCAPS2)
12143     {
12144       val = read_uleb128 (p, &len, end);
12145       p += len;
12146       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12147       display_sparc_hwcaps2 (val);
12148       return p;
12149     }
12150
12151   return display_tag_value (tag, p, end);
12152 }
12153
12154 static void
12155 print_mips_fp_abi_value (int val)
12156 {
12157   switch (val)
12158     {
12159     case Val_GNU_MIPS_ABI_FP_ANY:
12160       printf (_("Hard or soft float\n"));
12161       break;
12162     case Val_GNU_MIPS_ABI_FP_DOUBLE:
12163       printf (_("Hard float (double precision)\n"));
12164       break;
12165     case Val_GNU_MIPS_ABI_FP_SINGLE:
12166       printf (_("Hard float (single precision)\n"));
12167       break;
12168     case Val_GNU_MIPS_ABI_FP_SOFT:
12169       printf (_("Soft float\n"));
12170       break;
12171     case Val_GNU_MIPS_ABI_FP_OLD_64:
12172       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12173       break;
12174     case Val_GNU_MIPS_ABI_FP_XX:
12175       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12176       break;
12177     case Val_GNU_MIPS_ABI_FP_64:
12178       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12179       break;
12180     case Val_GNU_MIPS_ABI_FP_64A:
12181       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12182       break;
12183     default:
12184       printf ("??? (%d)\n", val);
12185       break;
12186     }
12187 }
12188
12189 static unsigned char *
12190 display_mips_gnu_attribute (unsigned char * p,
12191                             int tag,
12192                             const unsigned char * const end)
12193 {
12194   if (tag == Tag_GNU_MIPS_ABI_FP)
12195     {
12196       unsigned int len;
12197       int val;
12198
12199       val = read_uleb128 (p, &len, end);
12200       p += len;
12201       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12202
12203       print_mips_fp_abi_value (val);
12204
12205       return p;
12206    }
12207
12208   if (tag == Tag_GNU_MIPS_ABI_MSA)
12209     {
12210       unsigned int len;
12211       int val;
12212
12213       val = read_uleb128 (p, &len, end);
12214       p += len;
12215       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12216
12217       switch (val)
12218         {
12219         case Val_GNU_MIPS_ABI_MSA_ANY:
12220           printf (_("Any MSA or not\n"));
12221           break;
12222         case Val_GNU_MIPS_ABI_MSA_128:
12223           printf (_("128-bit MSA\n"));
12224           break;
12225         default:
12226           printf ("??? (%d)\n", val);
12227           break;
12228         }
12229       return p;
12230     }
12231
12232   return display_tag_value (tag & 1, p, end);
12233 }
12234
12235 static unsigned char *
12236 display_tic6x_attribute (unsigned char * p,
12237                          const unsigned char * const end)
12238 {
12239   int tag;
12240   unsigned int len;
12241   int val;
12242
12243   tag = read_uleb128 (p, &len, end);
12244   p += len;
12245
12246   switch (tag)
12247     {
12248     case Tag_ISA:
12249       val = read_uleb128 (p, &len, end);
12250       p += len;
12251       printf ("  Tag_ISA: ");
12252
12253       switch (val)
12254         {
12255         case C6XABI_Tag_ISA_none:
12256           printf (_("None\n"));
12257           break;
12258         case C6XABI_Tag_ISA_C62X:
12259           printf ("C62x\n");
12260           break;
12261         case C6XABI_Tag_ISA_C67X:
12262           printf ("C67x\n");
12263           break;
12264         case C6XABI_Tag_ISA_C67XP:
12265           printf ("C67x+\n");
12266           break;
12267         case C6XABI_Tag_ISA_C64X:
12268           printf ("C64x\n");
12269           break;
12270         case C6XABI_Tag_ISA_C64XP:
12271           printf ("C64x+\n");
12272           break;
12273         case C6XABI_Tag_ISA_C674X:
12274           printf ("C674x\n");
12275           break;
12276         default:
12277           printf ("??? (%d)\n", val);
12278           break;
12279         }
12280       return p;
12281
12282     case Tag_ABI_wchar_t:
12283       val = read_uleb128 (p, &len, end);
12284       p += len;
12285       printf ("  Tag_ABI_wchar_t: ");
12286       switch (val)
12287         {
12288         case 0:
12289           printf (_("Not used\n"));
12290           break;
12291         case 1:
12292           printf (_("2 bytes\n"));
12293           break;
12294         case 2:
12295           printf (_("4 bytes\n"));
12296           break;
12297         default:
12298           printf ("??? (%d)\n", val);
12299           break;
12300         }
12301       return p;
12302
12303     case Tag_ABI_stack_align_needed:
12304       val = read_uleb128 (p, &len, end);
12305       p += len;
12306       printf ("  Tag_ABI_stack_align_needed: ");
12307       switch (val)
12308         {
12309         case 0:
12310           printf (_("8-byte\n"));
12311           break;
12312         case 1:
12313           printf (_("16-byte\n"));
12314           break;
12315         default:
12316           printf ("??? (%d)\n", val);
12317           break;
12318         }
12319       return p;
12320
12321     case Tag_ABI_stack_align_preserved:
12322       val = read_uleb128 (p, &len, end);
12323       p += len;
12324       printf ("  Tag_ABI_stack_align_preserved: ");
12325       switch (val)
12326         {
12327         case 0:
12328           printf (_("8-byte\n"));
12329           break;
12330         case 1:
12331           printf (_("16-byte\n"));
12332           break;
12333         default:
12334           printf ("??? (%d)\n", val);
12335           break;
12336         }
12337       return p;
12338
12339     case Tag_ABI_DSBT:
12340       val = read_uleb128 (p, &len, end);
12341       p += len;
12342       printf ("  Tag_ABI_DSBT: ");
12343       switch (val)
12344         {
12345         case 0:
12346           printf (_("DSBT addressing not used\n"));
12347           break;
12348         case 1:
12349           printf (_("DSBT addressing used\n"));
12350           break;
12351         default:
12352           printf ("??? (%d)\n", val);
12353           break;
12354         }
12355       return p;
12356
12357     case Tag_ABI_PID:
12358       val = read_uleb128 (p, &len, end);
12359       p += len;
12360       printf ("  Tag_ABI_PID: ");
12361       switch (val)
12362         {
12363         case 0:
12364           printf (_("Data addressing position-dependent\n"));
12365           break;
12366         case 1:
12367           printf (_("Data addressing position-independent, GOT near DP\n"));
12368           break;
12369         case 2:
12370           printf (_("Data addressing position-independent, GOT far from DP\n"));
12371           break;
12372         default:
12373           printf ("??? (%d)\n", val);
12374           break;
12375         }
12376       return p;
12377
12378     case Tag_ABI_PIC:
12379       val = read_uleb128 (p, &len, end);
12380       p += len;
12381       printf ("  Tag_ABI_PIC: ");
12382       switch (val)
12383         {
12384         case 0:
12385           printf (_("Code addressing position-dependent\n"));
12386           break;
12387         case 1:
12388           printf (_("Code addressing position-independent\n"));
12389           break;
12390         default:
12391           printf ("??? (%d)\n", val);
12392           break;
12393         }
12394       return p;
12395
12396     case Tag_ABI_array_object_alignment:
12397       val = read_uleb128 (p, &len, end);
12398       p += len;
12399       printf ("  Tag_ABI_array_object_alignment: ");
12400       switch (val)
12401         {
12402         case 0:
12403           printf (_("8-byte\n"));
12404           break;
12405         case 1:
12406           printf (_("4-byte\n"));
12407           break;
12408         case 2:
12409           printf (_("16-byte\n"));
12410           break;
12411         default:
12412           printf ("??? (%d)\n", val);
12413           break;
12414         }
12415       return p;
12416
12417     case Tag_ABI_array_object_align_expected:
12418       val = read_uleb128 (p, &len, end);
12419       p += len;
12420       printf ("  Tag_ABI_array_object_align_expected: ");
12421       switch (val)
12422         {
12423         case 0:
12424           printf (_("8-byte\n"));
12425           break;
12426         case 1:
12427           printf (_("4-byte\n"));
12428           break;
12429         case 2:
12430           printf (_("16-byte\n"));
12431           break;
12432         default:
12433           printf ("??? (%d)\n", val);
12434           break;
12435         }
12436       return p;
12437
12438     case Tag_ABI_compatibility:
12439       val = read_uleb128 (p, &len, end);
12440       p += len;
12441       printf ("  Tag_ABI_compatibility: ");
12442       printf (_("flag = %d, vendor = %s\n"), val, p);
12443       p += strlen ((char *) p) + 1;
12444       return p;
12445
12446     case Tag_ABI_conformance:
12447       printf ("  Tag_ABI_conformance: ");
12448       printf ("\"%s\"\n", p);
12449       p += strlen ((char *) p) + 1;
12450       return p;
12451     }
12452
12453   return display_tag_value (tag, p, end);
12454 }
12455
12456 static void
12457 display_raw_attribute (unsigned char * p, unsigned char * end)
12458 {
12459   unsigned long addr = 0;
12460   size_t bytes = end - p;
12461
12462   assert (end > p);
12463   while (bytes)
12464     {
12465       int j;
12466       int k;
12467       int lbytes = (bytes > 16 ? 16 : bytes);
12468
12469       printf ("  0x%8.8lx ", addr);
12470
12471       for (j = 0; j < 16; j++)
12472         {
12473           if (j < lbytes)
12474             printf ("%2.2x", p[j]);
12475           else
12476             printf ("  ");
12477
12478           if ((j & 3) == 3)
12479             printf (" ");
12480         }
12481
12482       for (j = 0; j < lbytes; j++)
12483         {
12484           k = p[j];
12485           if (k >= ' ' && k < 0x7f)
12486             printf ("%c", k);
12487           else
12488             printf (".");
12489         }
12490
12491       putchar ('\n');
12492
12493       p  += lbytes;
12494       bytes -= lbytes;
12495       addr += lbytes;
12496     }
12497
12498   putchar ('\n');
12499 }
12500
12501 static unsigned char *
12502 display_msp430x_attribute (unsigned char * p,
12503                            const unsigned char * const end)
12504 {
12505   unsigned int len;
12506   int val;
12507   int tag;
12508
12509   tag = read_uleb128 (p, & len, end);
12510   p += len;
12511
12512   switch (tag)
12513     {
12514     case OFBA_MSPABI_Tag_ISA:
12515       val = read_uleb128 (p, &len, end);
12516       p += len;
12517       printf ("  Tag_ISA: ");
12518       switch (val)
12519         {
12520         case 0: printf (_("None\n")); break;
12521         case 1: printf (_("MSP430\n")); break;
12522         case 2: printf (_("MSP430X\n")); break;
12523         default: printf ("??? (%d)\n", val); break;
12524         }
12525       break;
12526
12527     case OFBA_MSPABI_Tag_Code_Model:
12528       val = read_uleb128 (p, &len, end);
12529       p += len;
12530       printf ("  Tag_Code_Model: ");
12531       switch (val)
12532         {
12533         case 0: printf (_("None\n")); break;
12534         case 1: printf (_("Small\n")); break;
12535         case 2: printf (_("Large\n")); break;
12536         default: printf ("??? (%d)\n", val); break;
12537         }
12538       break;
12539
12540     case OFBA_MSPABI_Tag_Data_Model:
12541       val = read_uleb128 (p, &len, end);
12542       p += len;
12543       printf ("  Tag_Data_Model: ");
12544       switch (val)
12545         {
12546         case 0: printf (_("None\n")); break;
12547         case 1: printf (_("Small\n")); break;
12548         case 2: printf (_("Large\n")); break;
12549         case 3: printf (_("Restricted Large\n")); break;
12550         default: printf ("??? (%d)\n", val); break;
12551         }
12552       break;
12553
12554     default:
12555       printf (_("  <unknown tag %d>: "), tag);
12556
12557       if (tag & 1)
12558         {
12559           printf ("\"%s\"\n", p);
12560           p += strlen ((char *) p) + 1;
12561         }
12562       else
12563         {
12564           val = read_uleb128 (p, &len, end);
12565           p += len;
12566           printf ("%d (0x%x)\n", val, val);
12567         }
12568       break;
12569    }
12570
12571   return p;
12572 }
12573
12574 static int
12575 process_attributes (FILE * file,
12576                     const char * public_name,
12577                     unsigned int proc_type,
12578                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12579                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12580 {
12581   Elf_Internal_Shdr * sect;
12582   unsigned char * contents;
12583   unsigned char * p;
12584   unsigned char * end;
12585   bfd_vma section_len;
12586   bfd_vma len;
12587   unsigned i;
12588
12589   /* Find the section header so that we get the size.  */
12590   for (i = 0, sect = section_headers;
12591        i < elf_header.e_shnum;
12592        i++, sect++)
12593     {
12594       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12595         continue;
12596
12597       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12598                                              sect->sh_size, _("attributes"));
12599       if (contents == NULL)
12600         continue;
12601
12602       p = contents;
12603       if (*p == 'A')
12604         {
12605           len = sect->sh_size - 1;
12606           p++;
12607
12608           while (len > 0)
12609             {
12610               unsigned int namelen;
12611               bfd_boolean public_section;
12612               bfd_boolean gnu_section;
12613
12614               if (len <= 4)
12615                 {
12616                   error (_("Tag section ends prematurely\n"));
12617                   break;
12618                 }
12619               section_len = byte_get (p, 4);
12620               p += 4;
12621
12622               if (section_len > len)
12623                 {
12624                   error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12625                           (unsigned) section_len, (unsigned) len);
12626                   section_len = len;
12627                 }
12628
12629               len -= section_len;
12630               section_len -= 4;
12631
12632               namelen = strnlen ((char *) p, section_len) + 1;
12633               if (namelen == 0 || namelen >= section_len)
12634                 {
12635                   error (_("Corrupt attribute section name\n"));
12636                   break;
12637                 }
12638
12639               printf (_("Attribute Section: %s\n"), p);
12640
12641               if (public_name && streq ((char *) p, public_name))
12642                 public_section = TRUE;
12643               else
12644                 public_section = FALSE;
12645
12646               if (streq ((char *) p, "gnu"))
12647                 gnu_section = TRUE;
12648               else
12649                 gnu_section = FALSE;
12650
12651               p += namelen;
12652               section_len -= namelen;
12653
12654               while (section_len > 0)
12655                 {
12656                   int tag;
12657                   int val;
12658                   bfd_vma size;
12659
12660                   /* PR binutils/17531: Safe handling of corrupt files.  */
12661                   if (section_len < 6)
12662                     {
12663                       error (_("Unused bytes at end of section\n"));
12664                       section_len = 0;
12665                       break;
12666                     }
12667
12668                   tag = *(p++);
12669                   size = byte_get (p, 4);
12670                   if (size > section_len)
12671                     {
12672                       error (_("Bad subsection length (%u > %u)\n"),
12673                               (unsigned) size, (unsigned) section_len);
12674                       size = section_len;
12675                     }
12676                   /* PR binutils/17531: Safe handling of corrupt files.  */
12677                   if (size < 6)
12678                     {
12679                       error (_("Bad subsection length (%u < 6)\n"),
12680                               (unsigned) size);
12681                       section_len = 0;
12682                       break;
12683                     }
12684
12685                   section_len -= size;
12686                   end = p + size - 1;
12687                   p += 4;
12688
12689                   switch (tag)
12690                     {
12691                     case 1:
12692                       printf (_("File Attributes\n"));
12693                       break;
12694                     case 2:
12695                       printf (_("Section Attributes:"));
12696                       goto do_numlist;
12697                     case 3:
12698                       printf (_("Symbol Attributes:"));
12699                     do_numlist:
12700                       for (;;)
12701                         {
12702                           unsigned int j;
12703
12704                           val = read_uleb128 (p, &j, end);
12705                           p += j;
12706                           if (val == 0)
12707                             break;
12708                           printf (" %d", val);
12709                         }
12710                       printf ("\n");
12711                       break;
12712                     default:
12713                       printf (_("Unknown tag: %d\n"), tag);
12714                       public_section = FALSE;
12715                       break;
12716                     }
12717
12718                   if (public_section)
12719                     {
12720                       while (p < end)
12721                         p = display_pub_attribute (p, end);
12722                     }
12723                   else if (gnu_section)
12724                     {
12725                       while (p < end)
12726                         p = display_gnu_attribute (p,
12727                                                    display_proc_gnu_attribute,
12728                                                    end);
12729                     }
12730                   else
12731                     {
12732                       printf (_("  Unknown section contexts\n"));
12733                       display_raw_attribute (p, end);
12734                       p = end;
12735                     }
12736                 }
12737             }
12738         }
12739       else
12740         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
12741
12742       free (contents);
12743     }
12744   return 1;
12745 }
12746
12747 static int
12748 process_arm_specific (FILE * file)
12749 {
12750   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12751                              display_arm_attribute, NULL);
12752 }
12753
12754 static int
12755 process_power_specific (FILE * file)
12756 {
12757   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12758                              display_power_gnu_attribute);
12759 }
12760
12761 static int
12762 process_sparc_specific (FILE * file)
12763 {
12764   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12765                              display_sparc_gnu_attribute);
12766 }
12767
12768 static int
12769 process_tic6x_specific (FILE * file)
12770 {
12771   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12772                              display_tic6x_attribute, NULL);
12773 }
12774
12775 static int
12776 process_msp430x_specific (FILE * file)
12777 {
12778   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12779                              display_msp430x_attribute, NULL);
12780 }
12781
12782 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12783    Print the Address, Access and Initial fields of an entry at VMA ADDR
12784    and return the VMA of the next entry.  */
12785
12786 static bfd_vma
12787 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12788 {
12789   printf ("  ");
12790   print_vma (addr, LONG_HEX);
12791   printf (" ");
12792   if (addr < pltgot + 0xfff0)
12793     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12794   else
12795     printf ("%10s", "");
12796   printf (" ");
12797   if (data == NULL)
12798     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12799   else
12800     {
12801       bfd_vma entry;
12802
12803       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12804       print_vma (entry, LONG_HEX);
12805     }
12806   return addr + (is_32bit_elf ? 4 : 8);
12807 }
12808
12809 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12810    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12811    ADDR and return the VMA of the next entry.  */
12812
12813 static bfd_vma
12814 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12815 {
12816   printf ("  ");
12817   print_vma (addr, LONG_HEX);
12818   printf (" ");
12819   if (data == NULL)
12820     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12821   else
12822     {
12823       bfd_vma entry;
12824
12825       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12826       print_vma (entry, LONG_HEX);
12827     }
12828   return addr + (is_32bit_elf ? 4 : 8);
12829 }
12830
12831 static void
12832 print_mips_ases (unsigned int mask)
12833 {
12834   if (mask & AFL_ASE_DSP)
12835     fputs ("\n\tDSP ASE", stdout);
12836   if (mask & AFL_ASE_DSPR2)
12837     fputs ("\n\tDSP R2 ASE", stdout);
12838   if (mask & AFL_ASE_EVA)
12839     fputs ("\n\tEnhanced VA Scheme", stdout);
12840   if (mask & AFL_ASE_MCU)
12841     fputs ("\n\tMCU (MicroController) ASE", stdout);
12842   if (mask & AFL_ASE_MDMX)
12843     fputs ("\n\tMDMX ASE", stdout);
12844   if (mask & AFL_ASE_MIPS3D)
12845     fputs ("\n\tMIPS-3D ASE", stdout);
12846   if (mask & AFL_ASE_MT)
12847     fputs ("\n\tMT ASE", stdout);
12848   if (mask & AFL_ASE_SMARTMIPS)
12849     fputs ("\n\tSmartMIPS ASE", stdout);
12850   if (mask & AFL_ASE_VIRT)
12851     fputs ("\n\tVZ ASE", stdout);
12852   if (mask & AFL_ASE_MSA)
12853     fputs ("\n\tMSA ASE", stdout);
12854   if (mask & AFL_ASE_MIPS16)
12855     fputs ("\n\tMIPS16 ASE", stdout);
12856   if (mask & AFL_ASE_MICROMIPS)
12857     fputs ("\n\tMICROMIPS ASE", stdout);
12858   if (mask & AFL_ASE_XPA)
12859     fputs ("\n\tXPA ASE", stdout);
12860   if (mask == 0)
12861     fprintf (stdout, "\n\t%s", _("None"));
12862   else if ((mask & ~AFL_ASE_MASK) != 0)
12863     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
12864 }
12865
12866 static void
12867 print_mips_isa_ext (unsigned int isa_ext)
12868 {
12869   switch (isa_ext)
12870     {
12871     case 0:
12872       fputs (_("None"), stdout);
12873       break;
12874     case AFL_EXT_XLR:
12875       fputs ("RMI XLR", stdout);
12876       break;
12877     case AFL_EXT_OCTEON3:
12878       fputs ("Cavium Networks Octeon3", stdout);
12879       break;
12880     case AFL_EXT_OCTEON2:
12881       fputs ("Cavium Networks Octeon2", stdout);
12882       break;
12883     case AFL_EXT_OCTEONP:
12884       fputs ("Cavium Networks OcteonP", stdout);
12885       break;
12886     case AFL_EXT_LOONGSON_3A:
12887       fputs ("Loongson 3A", stdout);
12888       break;
12889     case AFL_EXT_OCTEON:
12890       fputs ("Cavium Networks Octeon", stdout);
12891       break;
12892     case AFL_EXT_5900:
12893       fputs ("Toshiba R5900", stdout);
12894       break;
12895     case AFL_EXT_4650:
12896       fputs ("MIPS R4650", stdout);
12897       break;
12898     case AFL_EXT_4010:
12899       fputs ("LSI R4010", stdout);
12900       break;
12901     case AFL_EXT_4100:
12902       fputs ("NEC VR4100", stdout);
12903       break;
12904     case AFL_EXT_3900:
12905       fputs ("Toshiba R3900", stdout);
12906       break;
12907     case AFL_EXT_10000:
12908       fputs ("MIPS R10000", stdout);
12909       break;
12910     case AFL_EXT_SB1:
12911       fputs ("Broadcom SB-1", stdout);
12912       break;
12913     case AFL_EXT_4111:
12914       fputs ("NEC VR4111/VR4181", stdout);
12915       break;
12916     case AFL_EXT_4120:
12917       fputs ("NEC VR4120", stdout);
12918       break;
12919     case AFL_EXT_5400:
12920       fputs ("NEC VR5400", stdout);
12921       break;
12922     case AFL_EXT_5500:
12923       fputs ("NEC VR5500", stdout);
12924       break;
12925     case AFL_EXT_LOONGSON_2E:
12926       fputs ("ST Microelectronics Loongson 2E", stdout);
12927       break;
12928     case AFL_EXT_LOONGSON_2F:
12929       fputs ("ST Microelectronics Loongson 2F", stdout);
12930       break;
12931     default:
12932       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
12933     }
12934 }
12935
12936 static int
12937 get_mips_reg_size (int reg_size)
12938 {
12939   return (reg_size == AFL_REG_NONE) ? 0
12940          : (reg_size == AFL_REG_32) ? 32
12941          : (reg_size == AFL_REG_64) ? 64
12942          : (reg_size == AFL_REG_128) ? 128
12943          : -1;
12944 }
12945
12946 static int
12947 process_mips_specific (FILE * file)
12948 {
12949   Elf_Internal_Dyn * entry;
12950   Elf_Internal_Shdr *sect = NULL;
12951   size_t liblist_offset = 0;
12952   size_t liblistno = 0;
12953   size_t conflictsno = 0;
12954   size_t options_offset = 0;
12955   size_t conflicts_offset = 0;
12956   size_t pltrelsz = 0;
12957   size_t pltrel = 0;
12958   bfd_vma pltgot = 0;
12959   bfd_vma mips_pltgot = 0;
12960   bfd_vma jmprel = 0;
12961   bfd_vma local_gotno = 0;
12962   bfd_vma gotsym = 0;
12963   bfd_vma symtabno = 0;
12964
12965   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12966                       display_mips_gnu_attribute);
12967
12968   sect = find_section (".MIPS.abiflags");
12969
12970   if (sect != NULL)
12971     {
12972       Elf_External_ABIFlags_v0 *abiflags_ext;
12973       Elf_Internal_ABIFlags_v0 abiflags_in;
12974
12975       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
12976         fputs ("\nCorrupt ABI Flags section.\n", stdout);
12977       else
12978         {
12979           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
12980                                    sect->sh_size, _("MIPS ABI Flags section"));
12981           if (abiflags_ext)
12982             {
12983               abiflags_in.version = BYTE_GET (abiflags_ext->version);
12984               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
12985               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
12986               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
12987               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
12988               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
12989               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
12990               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
12991               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
12992               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
12993               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
12994
12995               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
12996               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
12997               if (abiflags_in.isa_rev > 1)
12998                 printf ("r%d", abiflags_in.isa_rev);
12999               printf ("\nGPR size: %d",
13000                       get_mips_reg_size (abiflags_in.gpr_size));
13001               printf ("\nCPR1 size: %d",
13002                       get_mips_reg_size (abiflags_in.cpr1_size));
13003               printf ("\nCPR2 size: %d",
13004                       get_mips_reg_size (abiflags_in.cpr2_size));
13005               fputs ("\nFP ABI: ", stdout);
13006               print_mips_fp_abi_value (abiflags_in.fp_abi);
13007               fputs ("ISA Extension: ", stdout);
13008               print_mips_isa_ext (abiflags_in.isa_ext);
13009               fputs ("\nASEs:", stdout);
13010               print_mips_ases (abiflags_in.ases);
13011               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13012               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13013               fputc ('\n', stdout);
13014               free (abiflags_ext);
13015             }
13016         }
13017     }
13018
13019   /* We have a lot of special sections.  Thanks SGI!  */
13020   if (dynamic_section == NULL)
13021     /* No information available.  */
13022     return 0;
13023
13024   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
13025     switch (entry->d_tag)
13026       {
13027       case DT_MIPS_LIBLIST:
13028         liblist_offset
13029           = offset_from_vma (file, entry->d_un.d_val,
13030                              liblistno * sizeof (Elf32_External_Lib));
13031         break;
13032       case DT_MIPS_LIBLISTNO:
13033         liblistno = entry->d_un.d_val;
13034         break;
13035       case DT_MIPS_OPTIONS:
13036         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13037         break;
13038       case DT_MIPS_CONFLICT:
13039         conflicts_offset
13040           = offset_from_vma (file, entry->d_un.d_val,
13041                              conflictsno * sizeof (Elf32_External_Conflict));
13042         break;
13043       case DT_MIPS_CONFLICTNO:
13044         conflictsno = entry->d_un.d_val;
13045         break;
13046       case DT_PLTGOT:
13047         pltgot = entry->d_un.d_ptr;
13048         break;
13049       case DT_MIPS_LOCAL_GOTNO:
13050         local_gotno = entry->d_un.d_val;
13051         break;
13052       case DT_MIPS_GOTSYM:
13053         gotsym = entry->d_un.d_val;
13054         break;
13055       case DT_MIPS_SYMTABNO:
13056         symtabno = entry->d_un.d_val;
13057         break;
13058       case DT_MIPS_PLTGOT:
13059         mips_pltgot = entry->d_un.d_ptr;
13060         break;
13061       case DT_PLTREL:
13062         pltrel = entry->d_un.d_val;
13063         break;
13064       case DT_PLTRELSZ:
13065         pltrelsz = entry->d_un.d_val;
13066         break;
13067       case DT_JMPREL:
13068         jmprel = entry->d_un.d_ptr;
13069         break;
13070       default:
13071         break;
13072       }
13073
13074   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13075     {
13076       Elf32_External_Lib * elib;
13077       size_t cnt;
13078
13079       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13080                                               liblistno,
13081                                               sizeof (Elf32_External_Lib),
13082                                               _("liblist section data"));
13083       if (elib)
13084         {
13085           printf (_("\nSection '.liblist' contains %lu entries:\n"),
13086                   (unsigned long) liblistno);
13087           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
13088                  stdout);
13089
13090           for (cnt = 0; cnt < liblistno; ++cnt)
13091             {
13092               Elf32_Lib liblist;
13093               time_t atime;
13094               char timebuf[20];
13095               struct tm * tmp;
13096
13097               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13098               atime = BYTE_GET (elib[cnt].l_time_stamp);
13099               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13100               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13101               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13102
13103               tmp = gmtime (&atime);
13104               snprintf (timebuf, sizeof (timebuf),
13105                         "%04u-%02u-%02uT%02u:%02u:%02u",
13106                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13107                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13108
13109               printf ("%3lu: ", (unsigned long) cnt);
13110               if (VALID_DYNAMIC_NAME (liblist.l_name))
13111                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13112               else
13113                 printf (_("<corrupt: %9ld>"), liblist.l_name);
13114               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13115                       liblist.l_version);
13116
13117               if (liblist.l_flags == 0)
13118                 puts (_(" NONE"));
13119               else
13120                 {
13121                   static const struct
13122                   {
13123                     const char * name;
13124                     int bit;
13125                   }
13126                   l_flags_vals[] =
13127                   {
13128                     { " EXACT_MATCH", LL_EXACT_MATCH },
13129                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13130                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13131                     { " EXPORTS", LL_EXPORTS },
13132                     { " DELAY_LOAD", LL_DELAY_LOAD },
13133                     { " DELTA", LL_DELTA }
13134                   };
13135                   int flags = liblist.l_flags;
13136                   size_t fcnt;
13137
13138                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13139                     if ((flags & l_flags_vals[fcnt].bit) != 0)
13140                       {
13141                         fputs (l_flags_vals[fcnt].name, stdout);
13142                         flags ^= l_flags_vals[fcnt].bit;
13143                       }
13144                   if (flags != 0)
13145                     printf (" %#x", (unsigned int) flags);
13146
13147                   puts ("");
13148                 }
13149             }
13150
13151           free (elib);
13152         }
13153     }
13154
13155   if (options_offset != 0)
13156     {
13157       Elf_External_Options * eopt;
13158       Elf_Internal_Options * iopt;
13159       Elf_Internal_Options * option;
13160       size_t offset;
13161       int cnt;
13162       sect = section_headers;
13163
13164       /* Find the section header so that we get the size.  */
13165       while (sect->sh_type != SHT_MIPS_OPTIONS)
13166         ++sect;
13167
13168       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13169                                                 sect->sh_size, _("options"));
13170       if (eopt)
13171         {
13172           iopt = (Elf_Internal_Options *)
13173               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13174           if (iopt == NULL)
13175             {
13176               error (_("Out of memory\n"));
13177               return 0;
13178             }
13179
13180           offset = cnt = 0;
13181           option = iopt;
13182
13183           while (offset < sect->sh_size)
13184             {
13185               Elf_External_Options * eoption;
13186
13187               eoption = (Elf_External_Options *) ((char *) eopt + offset);
13188
13189               option->kind = BYTE_GET (eoption->kind);
13190               option->size = BYTE_GET (eoption->size);
13191               option->section = BYTE_GET (eoption->section);
13192               option->info = BYTE_GET (eoption->info);
13193
13194               offset += option->size;
13195
13196               ++option;
13197               ++cnt;
13198             }
13199
13200           printf (_("\nSection '%s' contains %d entries:\n"),
13201                   SECTION_NAME (sect), cnt);
13202
13203           option = iopt;
13204
13205           while (cnt-- > 0)
13206             {
13207               size_t len;
13208
13209               switch (option->kind)
13210                 {
13211                 case ODK_NULL:
13212                   /* This shouldn't happen.  */
13213                   printf (" NULL       %d %lx", option->section, option->info);
13214                   break;
13215                 case ODK_REGINFO:
13216                   printf (" REGINFO    ");
13217                   if (elf_header.e_machine == EM_MIPS)
13218                     {
13219                       /* 32bit form.  */
13220                       Elf32_External_RegInfo * ereg;
13221                       Elf32_RegInfo reginfo;
13222
13223                       ereg = (Elf32_External_RegInfo *) (option + 1);
13224                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13225                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13226                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13227                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13228                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13229                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13230
13231                       printf ("GPR %08lx  GP 0x%lx\n",
13232                               reginfo.ri_gprmask,
13233                               (unsigned long) reginfo.ri_gp_value);
13234                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13235                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13236                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13237                     }
13238                   else
13239                     {
13240                       /* 64 bit form.  */
13241                       Elf64_External_RegInfo * ereg;
13242                       Elf64_Internal_RegInfo reginfo;
13243
13244                       ereg = (Elf64_External_RegInfo *) (option + 1);
13245                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
13246                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13247                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13248                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13249                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13250                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
13251
13252                       printf ("GPR %08lx  GP 0x",
13253                               reginfo.ri_gprmask);
13254                       printf_vma (reginfo.ri_gp_value);
13255                       printf ("\n");
13256
13257                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13258                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13259                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13260                     }
13261                   ++option;
13262                   continue;
13263                 case ODK_EXCEPTIONS:
13264                   fputs (" EXCEPTIONS fpe_min(", stdout);
13265                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13266                   fputs (") fpe_max(", stdout);
13267                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13268                   fputs (")", stdout);
13269
13270                   if (option->info & OEX_PAGE0)
13271                     fputs (" PAGE0", stdout);
13272                   if (option->info & OEX_SMM)
13273                     fputs (" SMM", stdout);
13274                   if (option->info & OEX_FPDBUG)
13275                     fputs (" FPDBUG", stdout);
13276                   if (option->info & OEX_DISMISS)
13277                     fputs (" DISMISS", stdout);
13278                   break;
13279                 case ODK_PAD:
13280                   fputs (" PAD       ", stdout);
13281                   if (option->info & OPAD_PREFIX)
13282                     fputs (" PREFIX", stdout);
13283                   if (option->info & OPAD_POSTFIX)
13284                     fputs (" POSTFIX", stdout);
13285                   if (option->info & OPAD_SYMBOL)
13286                     fputs (" SYMBOL", stdout);
13287                   break;
13288                 case ODK_HWPATCH:
13289                   fputs (" HWPATCH   ", stdout);
13290                   if (option->info & OHW_R4KEOP)
13291                     fputs (" R4KEOP", stdout);
13292                   if (option->info & OHW_R8KPFETCH)
13293                     fputs (" R8KPFETCH", stdout);
13294                   if (option->info & OHW_R5KEOP)
13295                     fputs (" R5KEOP", stdout);
13296                   if (option->info & OHW_R5KCVTL)
13297                     fputs (" R5KCVTL", stdout);
13298                   break;
13299                 case ODK_FILL:
13300                   fputs (" FILL       ", stdout);
13301                   /* XXX Print content of info word?  */
13302                   break;
13303                 case ODK_TAGS:
13304                   fputs (" TAGS       ", stdout);
13305                   /* XXX Print content of info word?  */
13306                   break;
13307                 case ODK_HWAND:
13308                   fputs (" HWAND     ", stdout);
13309                   if (option->info & OHWA0_R4KEOP_CHECKED)
13310                     fputs (" R4KEOP_CHECKED", stdout);
13311                   if (option->info & OHWA0_R4KEOP_CLEAN)
13312                     fputs (" R4KEOP_CLEAN", stdout);
13313                   break;
13314                 case ODK_HWOR:
13315                   fputs (" HWOR      ", stdout);
13316                   if (option->info & OHWA0_R4KEOP_CHECKED)
13317                     fputs (" R4KEOP_CHECKED", stdout);
13318                   if (option->info & OHWA0_R4KEOP_CLEAN)
13319                     fputs (" R4KEOP_CLEAN", stdout);
13320                   break;
13321                 case ODK_GP_GROUP:
13322                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
13323                           option->info & OGP_GROUP,
13324                           (option->info & OGP_SELF) >> 16);
13325                   break;
13326                 case ODK_IDENT:
13327                   printf (" IDENT     %#06lx  self-contained %#06lx",
13328                           option->info & OGP_GROUP,
13329                           (option->info & OGP_SELF) >> 16);
13330                   break;
13331                 default:
13332                   /* This shouldn't happen.  */
13333                   printf (" %3d ???     %d %lx",
13334                           option->kind, option->section, option->info);
13335                   break;
13336                 }
13337
13338               len = sizeof (* eopt);
13339               while (len < option->size)
13340                 if (((char *) option)[len] >= ' '
13341                     && ((char *) option)[len] < 0x7f)
13342                   printf ("%c", ((char *) option)[len++]);
13343                 else
13344                   printf ("\\%03o", ((char *) option)[len++]);
13345
13346               fputs ("\n", stdout);
13347               ++option;
13348             }
13349
13350           free (eopt);
13351         }
13352     }
13353
13354   if (conflicts_offset != 0 && conflictsno != 0)
13355     {
13356       Elf32_Conflict * iconf;
13357       size_t cnt;
13358
13359       if (dynamic_symbols == NULL)
13360         {
13361           error (_("conflict list found without a dynamic symbol table\n"));
13362           return 0;
13363         }
13364
13365       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13366       if (iconf == NULL)
13367         {
13368           error (_("Out of memory\n"));
13369           return 0;
13370         }
13371
13372       if (is_32bit_elf)
13373         {
13374           Elf32_External_Conflict * econf32;
13375
13376           econf32 = (Elf32_External_Conflict *)
13377               get_data (NULL, file, conflicts_offset, conflictsno,
13378                         sizeof (* econf32), _("conflict"));
13379           if (!econf32)
13380             return 0;
13381
13382           for (cnt = 0; cnt < conflictsno; ++cnt)
13383             iconf[cnt] = BYTE_GET (econf32[cnt]);
13384
13385           free (econf32);
13386         }
13387       else
13388         {
13389           Elf64_External_Conflict * econf64;
13390
13391           econf64 = (Elf64_External_Conflict *)
13392               get_data (NULL, file, conflicts_offset, conflictsno,
13393                         sizeof (* econf64), _("conflict"));
13394           if (!econf64)
13395             return 0;
13396
13397           for (cnt = 0; cnt < conflictsno; ++cnt)
13398             iconf[cnt] = BYTE_GET (econf64[cnt]);
13399
13400           free (econf64);
13401         }
13402
13403       printf (_("\nSection '.conflict' contains %lu entries:\n"),
13404               (unsigned long) conflictsno);
13405       puts (_("  Num:    Index       Value  Name"));
13406
13407       for (cnt = 0; cnt < conflictsno; ++cnt)
13408         {
13409           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
13410
13411           if (iconf[cnt] >= num_dynamic_syms)
13412             printf (_("<corrupt symbol index>"));
13413           else
13414             {
13415               Elf_Internal_Sym * psym;
13416
13417               psym = & dynamic_symbols[iconf[cnt]];
13418               print_vma (psym->st_value, FULL_HEX);
13419               putchar (' ');
13420               if (VALID_DYNAMIC_NAME (psym->st_name))
13421                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13422               else
13423                 printf (_("<corrupt: %14ld>"), psym->st_name);
13424             }
13425           putchar ('\n');
13426         }
13427
13428       free (iconf);
13429     }
13430
13431   if (pltgot != 0 && local_gotno != 0)
13432     {
13433       bfd_vma ent, local_end, global_end;
13434       size_t i, offset;
13435       unsigned char * data;
13436       int addr_size;
13437
13438       ent = pltgot;
13439       addr_size = (is_32bit_elf ? 4 : 8);
13440       local_end = pltgot + local_gotno * addr_size;
13441       global_end = local_end + (symtabno - gotsym) * addr_size;
13442
13443       offset = offset_from_vma (file, pltgot, global_end - pltgot);
13444       data = (unsigned char *) get_data (NULL, file, offset,
13445                                          global_end - pltgot, 1,
13446                                          _("Global Offset Table data"));
13447       if (data == NULL)
13448         return 0;
13449
13450       printf (_("\nPrimary GOT:\n"));
13451       printf (_(" Canonical gp value: "));
13452       print_vma (pltgot + 0x7ff0, LONG_HEX);
13453       printf ("\n\n");
13454
13455       printf (_(" Reserved entries:\n"));
13456       printf (_("  %*s %10s %*s Purpose\n"),
13457               addr_size * 2, _("Address"), _("Access"),
13458               addr_size * 2, _("Initial"));
13459       ent = print_mips_got_entry (data, pltgot, ent);
13460       printf (_(" Lazy resolver\n"));
13461       if (data
13462           && (byte_get (data + ent - pltgot, addr_size)
13463               >> (addr_size * 8 - 1)) != 0)
13464         {
13465           ent = print_mips_got_entry (data, pltgot, ent);
13466           printf (_(" Module pointer (GNU extension)\n"));
13467         }
13468       printf ("\n");
13469
13470       if (ent < local_end)
13471         {
13472           printf (_(" Local entries:\n"));
13473           printf ("  %*s %10s %*s\n",
13474                   addr_size * 2, _("Address"), _("Access"),
13475                   addr_size * 2, _("Initial"));
13476           while (ent < local_end)
13477             {
13478               ent = print_mips_got_entry (data, pltgot, ent);
13479               printf ("\n");
13480             }
13481           printf ("\n");
13482         }
13483
13484       if (gotsym < symtabno)
13485         {
13486           int sym_width;
13487
13488           printf (_(" Global entries:\n"));
13489           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
13490                   addr_size * 2, _("Address"),
13491                   _("Access"),
13492                   addr_size * 2, _("Initial"),
13493                   addr_size * 2, _("Sym.Val."),
13494                   _("Type"),
13495                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
13496                   _("Ndx"), _("Name"));
13497
13498           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13499
13500           for (i = gotsym; i < symtabno; i++)
13501             {
13502               ent = print_mips_got_entry (data, pltgot, ent);
13503               printf (" ");
13504
13505               if (dynamic_symbols == NULL)
13506                 printf (_("<no dynamic symbols>"));
13507               else if (i < num_dynamic_syms)
13508                 {
13509                   Elf_Internal_Sym * psym = dynamic_symbols + i;
13510
13511                   print_vma (psym->st_value, LONG_HEX);
13512                   printf (" %-7s %3s ",
13513                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13514                           get_symbol_index_type (psym->st_shndx));
13515
13516                   if (VALID_DYNAMIC_NAME (psym->st_name))
13517                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13518                   else
13519                     printf (_("<corrupt: %14ld>"), psym->st_name);
13520                 }
13521               else
13522                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"), i);
13523
13524               printf ("\n");
13525             }
13526           printf ("\n");
13527         }
13528
13529       if (data)
13530         free (data);
13531     }
13532
13533   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13534     {
13535       bfd_vma ent, end;
13536       size_t offset, rel_offset;
13537       unsigned long count, i;
13538       unsigned char * data;
13539       int addr_size, sym_width;
13540       Elf_Internal_Rela * rels;
13541
13542       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13543       if (pltrel == DT_RELA)
13544         {
13545           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13546             return 0;
13547         }
13548       else
13549         {
13550           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13551             return 0;
13552         }
13553
13554       ent = mips_pltgot;
13555       addr_size = (is_32bit_elf ? 4 : 8);
13556       end = mips_pltgot + (2 + count) * addr_size;
13557
13558       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13559       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13560                                          1, _("Procedure Linkage Table data"));
13561       if (data == NULL)
13562         return 0;
13563
13564       printf ("\nPLT GOT:\n\n");
13565       printf (_(" Reserved entries:\n"));
13566       printf (_("  %*s %*s Purpose\n"),
13567               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13568       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13569       printf (_(" PLT lazy resolver\n"));
13570       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13571       printf (_(" Module pointer\n"));
13572       printf ("\n");
13573
13574       printf (_(" Entries:\n"));
13575       printf ("  %*s %*s %*s %-7s %3s %s\n",
13576               addr_size * 2, _("Address"),
13577               addr_size * 2, _("Initial"),
13578               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13579       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13580       for (i = 0; i < count; i++)
13581         {
13582           unsigned long index = get_reloc_symindex (rels[i].r_info);
13583
13584           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13585           printf (" ");
13586
13587           if (index >= num_dynamic_syms)
13588             printf (_("<corrupt symbol index: %lu>"), index);
13589           else
13590             {
13591               Elf_Internal_Sym * psym = dynamic_symbols + index;
13592
13593               print_vma (psym->st_value, LONG_HEX);
13594               printf (" %-7s %3s ",
13595                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13596                       get_symbol_index_type (psym->st_shndx));
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           printf ("\n");
13603         }
13604       printf ("\n");
13605
13606       if (data)
13607         free (data);
13608       free (rels);
13609     }
13610
13611   return 1;
13612 }
13613
13614 static int
13615 process_nds32_specific (FILE * file)
13616 {
13617   Elf_Internal_Shdr *sect = NULL;
13618
13619   sect = find_section (".nds32_e_flags");
13620   if (sect != NULL)
13621     {
13622       unsigned int *flag;
13623
13624       printf ("\nNDS32 elf flags section:\n");
13625       flag = get_data (NULL, file, sect->sh_offset, 1,
13626                        sect->sh_size, _("NDS32 elf flags section"));
13627
13628       switch ((*flag) & 0x3)
13629         {
13630         case 0:
13631           printf ("(VEC_SIZE):\tNo entry.\n");
13632           break;
13633         case 1:
13634           printf ("(VEC_SIZE):\t4 bytes\n");
13635           break;
13636         case 2:
13637           printf ("(VEC_SIZE):\t16 bytes\n");
13638           break;
13639         case 3:
13640           printf ("(VEC_SIZE):\treserved\n");
13641           break;
13642         }
13643     }
13644
13645   return TRUE;
13646 }
13647
13648 static int
13649 process_gnu_liblist (FILE * file)
13650 {
13651   Elf_Internal_Shdr * section;
13652   Elf_Internal_Shdr * string_sec;
13653   Elf32_External_Lib * elib;
13654   char * strtab;
13655   size_t strtab_size;
13656   size_t cnt;
13657   unsigned i;
13658
13659   if (! do_arch)
13660     return 0;
13661
13662   for (i = 0, section = section_headers;
13663        i < elf_header.e_shnum;
13664        i++, section++)
13665     {
13666       switch (section->sh_type)
13667         {
13668         case SHT_GNU_LIBLIST:
13669           if (section->sh_link >= elf_header.e_shnum)
13670             break;
13671
13672           elib = (Elf32_External_Lib *)
13673               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13674                         _("liblist section data"));
13675
13676           if (elib == NULL)
13677             break;
13678           string_sec = section_headers + section->sh_link;
13679
13680           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13681                                       string_sec->sh_size,
13682                                       _("liblist string table"));
13683           if (strtab == NULL
13684               || section->sh_entsize != sizeof (Elf32_External_Lib))
13685             {
13686               free (elib);
13687               free (strtab);
13688               break;
13689             }
13690           strtab_size = string_sec->sh_size;
13691
13692           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13693                   SECTION_NAME (section),
13694                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13695
13696           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13697
13698           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13699                ++cnt)
13700             {
13701               Elf32_Lib liblist;
13702               time_t atime;
13703               char timebuf[20];
13704               struct tm * tmp;
13705
13706               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13707               atime = BYTE_GET (elib[cnt].l_time_stamp);
13708               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13709               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13710               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13711
13712               tmp = gmtime (&atime);
13713               snprintf (timebuf, sizeof (timebuf),
13714                         "%04u-%02u-%02uT%02u:%02u:%02u",
13715                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13716                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13717
13718               printf ("%3lu: ", (unsigned long) cnt);
13719               if (do_wide)
13720                 printf ("%-20s", liblist.l_name < strtab_size
13721                         ? strtab + liblist.l_name : _("<corrupt>"));
13722               else
13723                 printf ("%-20.20s", liblist.l_name < strtab_size
13724                         ? strtab + liblist.l_name : _("<corrupt>"));
13725               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13726                       liblist.l_version, liblist.l_flags);
13727             }
13728
13729           free (elib);
13730           free (strtab);
13731         }
13732     }
13733
13734   return 1;
13735 }
13736
13737 static const char *
13738 get_note_type (unsigned e_type)
13739 {
13740   static char buff[64];
13741
13742   if (elf_header.e_type == ET_CORE)
13743     switch (e_type)
13744       {
13745       case NT_AUXV:
13746         return _("NT_AUXV (auxiliary vector)");
13747       case NT_PRSTATUS:
13748         return _("NT_PRSTATUS (prstatus structure)");
13749       case NT_FPREGSET:
13750         return _("NT_FPREGSET (floating point registers)");
13751       case NT_PRPSINFO:
13752         return _("NT_PRPSINFO (prpsinfo structure)");
13753       case NT_TASKSTRUCT:
13754         return _("NT_TASKSTRUCT (task structure)");
13755       case NT_PRXFPREG:
13756         return _("NT_PRXFPREG (user_xfpregs structure)");
13757       case NT_PPC_VMX:
13758         return _("NT_PPC_VMX (ppc Altivec registers)");
13759       case NT_PPC_VSX:
13760         return _("NT_PPC_VSX (ppc VSX registers)");
13761       case NT_386_TLS:
13762         return _("NT_386_TLS (x86 TLS information)");
13763       case NT_386_IOPERM:
13764         return _("NT_386_IOPERM (x86 I/O permissions)");
13765       case NT_X86_XSTATE:
13766         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13767       case NT_S390_HIGH_GPRS:
13768         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13769       case NT_S390_TIMER:
13770         return _("NT_S390_TIMER (s390 timer register)");
13771       case NT_S390_TODCMP:
13772         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13773       case NT_S390_TODPREG:
13774         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13775       case NT_S390_CTRS:
13776         return _("NT_S390_CTRS (s390 control registers)");
13777       case NT_S390_PREFIX:
13778         return _("NT_S390_PREFIX (s390 prefix register)");
13779       case NT_S390_LAST_BREAK:
13780         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13781       case NT_S390_SYSTEM_CALL:
13782         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13783       case NT_S390_TDB:
13784         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13785       case NT_ARM_VFP:
13786         return _("NT_ARM_VFP (arm VFP registers)");
13787       case NT_ARM_TLS:
13788         return _("NT_ARM_TLS (AArch TLS registers)");
13789       case NT_ARM_HW_BREAK:
13790         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13791       case NT_ARM_HW_WATCH:
13792         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13793       case NT_PSTATUS:
13794         return _("NT_PSTATUS (pstatus structure)");
13795       case NT_FPREGS:
13796         return _("NT_FPREGS (floating point registers)");
13797       case NT_PSINFO:
13798         return _("NT_PSINFO (psinfo structure)");
13799       case NT_LWPSTATUS:
13800         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13801       case NT_LWPSINFO:
13802         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13803       case NT_WIN32PSTATUS:
13804         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13805       case NT_SIGINFO:
13806         return _("NT_SIGINFO (siginfo_t data)");
13807       case NT_FILE:
13808         return _("NT_FILE (mapped files)");
13809       default:
13810         break;
13811       }
13812   else
13813     switch (e_type)
13814       {
13815       case NT_VERSION:
13816         return _("NT_VERSION (version)");
13817       case NT_ARCH:
13818         return _("NT_ARCH (architecture)");
13819       default:
13820         break;
13821       }
13822
13823   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13824   return buff;
13825 }
13826
13827 static int
13828 print_core_note (Elf_Internal_Note *pnote)
13829 {
13830   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13831   bfd_vma count, page_size;
13832   unsigned char *descdata, *filenames, *descend;
13833
13834   if (pnote->type != NT_FILE)
13835     return 1;
13836
13837 #ifndef BFD64
13838   if (!is_32bit_elf)
13839     {
13840       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13841       /* Still "successful".  */
13842       return 1;
13843     }
13844 #endif
13845
13846   if (pnote->descsz < 2 * addr_size)
13847     {
13848       printf (_("    Malformed note - too short for header\n"));
13849       return 0;
13850     }
13851
13852   descdata = (unsigned char *) pnote->descdata;
13853   descend = descdata + pnote->descsz;
13854
13855   if (descdata[pnote->descsz - 1] != '\0')
13856     {
13857       printf (_("    Malformed note - does not end with \\0\n"));
13858       return 0;
13859     }
13860
13861   count = byte_get (descdata, addr_size);
13862   descdata += addr_size;
13863
13864   page_size = byte_get (descdata, addr_size);
13865   descdata += addr_size;
13866
13867   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13868     {
13869       printf (_("    Malformed note - too short for supplied file count\n"));
13870       return 0;
13871     }
13872
13873   printf (_("    Page size: "));
13874   print_vma (page_size, DEC);
13875   printf ("\n");
13876
13877   printf (_("    %*s%*s%*s\n"),
13878           (int) (2 + 2 * addr_size), _("Start"),
13879           (int) (4 + 2 * addr_size), _("End"),
13880           (int) (4 + 2 * addr_size), _("Page Offset"));
13881   filenames = descdata + count * 3 * addr_size;
13882   while (--count > 0)
13883     {
13884       bfd_vma start, end, file_ofs;
13885
13886       if (filenames == descend)
13887         {
13888           printf (_("    Malformed note - filenames end too early\n"));
13889           return 0;
13890         }
13891
13892       start = byte_get (descdata, addr_size);
13893       descdata += addr_size;
13894       end = byte_get (descdata, addr_size);
13895       descdata += addr_size;
13896       file_ofs = byte_get (descdata, addr_size);
13897       descdata += addr_size;
13898
13899       printf ("    ");
13900       print_vma (start, FULL_HEX);
13901       printf ("  ");
13902       print_vma (end, FULL_HEX);
13903       printf ("  ");
13904       print_vma (file_ofs, FULL_HEX);
13905       printf ("\n        %s\n", filenames);
13906
13907       filenames += 1 + strlen ((char *) filenames);
13908     }
13909
13910   return 1;
13911 }
13912
13913 static const char *
13914 get_gnu_elf_note_type (unsigned e_type)
13915 {
13916   static char buff[64];
13917
13918   switch (e_type)
13919     {
13920     case NT_GNU_ABI_TAG:
13921       return _("NT_GNU_ABI_TAG (ABI version tag)");
13922     case NT_GNU_HWCAP:
13923       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13924     case NT_GNU_BUILD_ID:
13925       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13926     case NT_GNU_GOLD_VERSION:
13927       return _("NT_GNU_GOLD_VERSION (gold version)");
13928     default:
13929       break;
13930     }
13931
13932   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13933   return buff;
13934 }
13935
13936 static int
13937 print_gnu_note (Elf_Internal_Note *pnote)
13938 {
13939   switch (pnote->type)
13940     {
13941     case NT_GNU_BUILD_ID:
13942       {
13943         unsigned long i;
13944
13945         printf (_("    Build ID: "));
13946         for (i = 0; i < pnote->descsz; ++i)
13947           printf ("%02x", pnote->descdata[i] & 0xff);
13948         printf ("\n");
13949       }
13950       break;
13951
13952     case NT_GNU_ABI_TAG:
13953       {
13954         unsigned long os, major, minor, subminor;
13955         const char *osname;
13956
13957         os = byte_get ((unsigned char *) pnote->descdata, 4);
13958         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13959         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13960         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13961
13962         switch (os)
13963           {
13964           case GNU_ABI_TAG_LINUX:
13965             osname = "Linux";
13966             break;
13967           case GNU_ABI_TAG_HURD:
13968             osname = "Hurd";
13969             break;
13970           case GNU_ABI_TAG_SOLARIS:
13971             osname = "Solaris";
13972             break;
13973           case GNU_ABI_TAG_FREEBSD:
13974             osname = "FreeBSD";
13975             break;
13976           case GNU_ABI_TAG_NETBSD:
13977             osname = "NetBSD";
13978             break;
13979           default:
13980             osname = "Unknown";
13981             break;
13982           }
13983
13984         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13985                 major, minor, subminor);
13986       }
13987       break;
13988
13989     case NT_GNU_GOLD_VERSION:
13990       {
13991         unsigned long i;
13992
13993         printf (_("    Version: "));
13994         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13995           printf ("%c", pnote->descdata[i]);
13996         printf ("\n");
13997       }
13998       break;
13999     }
14000
14001   return 1;
14002 }
14003
14004 static const char *
14005 get_netbsd_elfcore_note_type (unsigned e_type)
14006 {
14007   static char buff[64];
14008
14009   if (e_type == NT_NETBSDCORE_PROCINFO)
14010     {
14011       /* NetBSD core "procinfo" structure.  */
14012       return _("NetBSD procinfo structure");
14013     }
14014
14015   /* As of Jan 2002 there are no other machine-independent notes
14016      defined for NetBSD core files.  If the note type is less
14017      than the start of the machine-dependent note types, we don't
14018      understand it.  */
14019
14020   if (e_type < NT_NETBSDCORE_FIRSTMACH)
14021     {
14022       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14023       return buff;
14024     }
14025
14026   switch (elf_header.e_machine)
14027     {
14028     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14029        and PT_GETFPREGS == mach+2.  */
14030
14031     case EM_OLD_ALPHA:
14032     case EM_ALPHA:
14033     case EM_SPARC:
14034     case EM_SPARC32PLUS:
14035     case EM_SPARCV9:
14036       switch (e_type)
14037         {
14038         case NT_NETBSDCORE_FIRSTMACH + 0:
14039           return _("PT_GETREGS (reg structure)");
14040         case NT_NETBSDCORE_FIRSTMACH + 2:
14041           return _("PT_GETFPREGS (fpreg structure)");
14042         default:
14043           break;
14044         }
14045       break;
14046
14047     /* On all other arch's, PT_GETREGS == mach+1 and
14048        PT_GETFPREGS == mach+3.  */
14049     default:
14050       switch (e_type)
14051         {
14052         case NT_NETBSDCORE_FIRSTMACH + 1:
14053           return _("PT_GETREGS (reg structure)");
14054         case NT_NETBSDCORE_FIRSTMACH + 3:
14055           return _("PT_GETFPREGS (fpreg structure)");
14056         default:
14057           break;
14058         }
14059     }
14060
14061   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14062             e_type - NT_NETBSDCORE_FIRSTMACH);
14063   return buff;
14064 }
14065
14066 static const char *
14067 get_stapsdt_note_type (unsigned e_type)
14068 {
14069   static char buff[64];
14070
14071   switch (e_type)
14072     {
14073     case NT_STAPSDT:
14074       return _("NT_STAPSDT (SystemTap probe descriptors)");
14075
14076     default:
14077       break;
14078     }
14079
14080   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14081   return buff;
14082 }
14083
14084 static int
14085 print_stapsdt_note (Elf_Internal_Note *pnote)
14086 {
14087   int addr_size = is_32bit_elf ? 4 : 8;
14088   char *data = pnote->descdata;
14089   char *data_end = pnote->descdata + pnote->descsz;
14090   bfd_vma pc, base_addr, semaphore;
14091   char *provider, *probe, *arg_fmt;
14092
14093   pc = byte_get ((unsigned char *) data, addr_size);
14094   data += addr_size;
14095   base_addr = byte_get ((unsigned char *) data, addr_size);
14096   data += addr_size;
14097   semaphore = byte_get ((unsigned char *) data, addr_size);
14098   data += addr_size;
14099
14100   provider = data;
14101   data += strlen (data) + 1;
14102   probe = data;
14103   data += strlen (data) + 1;
14104   arg_fmt = data;
14105   data += strlen (data) + 1;
14106
14107   printf (_("    Provider: %s\n"), provider);
14108   printf (_("    Name: %s\n"), probe);
14109   printf (_("    Location: "));
14110   print_vma (pc, FULL_HEX);
14111   printf (_(", Base: "));
14112   print_vma (base_addr, FULL_HEX);
14113   printf (_(", Semaphore: "));
14114   print_vma (semaphore, FULL_HEX);
14115   printf ("\n");
14116   printf (_("    Arguments: %s\n"), arg_fmt);
14117
14118   return data == data_end;
14119 }
14120
14121 static const char *
14122 get_ia64_vms_note_type (unsigned e_type)
14123 {
14124   static char buff[64];
14125
14126   switch (e_type)
14127     {
14128     case NT_VMS_MHD:
14129       return _("NT_VMS_MHD (module header)");
14130     case NT_VMS_LNM:
14131       return _("NT_VMS_LNM (language name)");
14132     case NT_VMS_SRC:
14133       return _("NT_VMS_SRC (source files)");
14134     case NT_VMS_TITLE:
14135       return "NT_VMS_TITLE";
14136     case NT_VMS_EIDC:
14137       return _("NT_VMS_EIDC (consistency check)");
14138     case NT_VMS_FPMODE:
14139       return _("NT_VMS_FPMODE (FP mode)");
14140     case NT_VMS_LINKTIME:
14141       return "NT_VMS_LINKTIME";
14142     case NT_VMS_IMGNAM:
14143       return _("NT_VMS_IMGNAM (image name)");
14144     case NT_VMS_IMGID:
14145       return _("NT_VMS_IMGID (image id)");
14146     case NT_VMS_LINKID:
14147       return _("NT_VMS_LINKID (link id)");
14148     case NT_VMS_IMGBID:
14149       return _("NT_VMS_IMGBID (build id)");
14150     case NT_VMS_GSTNAM:
14151       return _("NT_VMS_GSTNAM (sym table name)");
14152     case NT_VMS_ORIG_DYN:
14153       return "NT_VMS_ORIG_DYN";
14154     case NT_VMS_PATCHTIME:
14155       return "NT_VMS_PATCHTIME";
14156     default:
14157       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14158       return buff;
14159     }
14160 }
14161
14162 static int
14163 print_ia64_vms_note (Elf_Internal_Note * pnote)
14164 {
14165   switch (pnote->type)
14166     {
14167     case NT_VMS_MHD:
14168       if (pnote->descsz > 36)
14169         {
14170           size_t l = strlen (pnote->descdata + 34);
14171           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
14172           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
14173           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
14174           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
14175         }
14176       else
14177         printf (_("    Invalid size\n"));
14178       break;
14179     case NT_VMS_LNM:
14180       printf (_("   Language: %s\n"), pnote->descdata);
14181       break;
14182 #ifdef BFD64
14183     case NT_VMS_FPMODE:
14184       printf (_("   Floating Point mode: "));
14185       printf ("0x%016" BFD_VMA_FMT "x\n",
14186               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14187       break;
14188     case NT_VMS_LINKTIME:
14189       printf (_("   Link time: "));
14190       print_vms_time
14191         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14192       printf ("\n");
14193       break;
14194     case NT_VMS_PATCHTIME:
14195       printf (_("   Patch time: "));
14196       print_vms_time
14197         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14198       printf ("\n");
14199       break;
14200     case NT_VMS_ORIG_DYN:
14201       printf (_("   Major id: %u,  minor id: %u\n"),
14202               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14203               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14204       printf (_("   Last modified  : "));
14205       print_vms_time
14206         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14207       printf (_("\n   Link flags  : "));
14208       printf ("0x%016" BFD_VMA_FMT "x\n",
14209               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14210       printf (_("   Header flags: 0x%08x\n"),
14211               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14212       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
14213       break;
14214 #endif
14215     case NT_VMS_IMGNAM:
14216       printf (_("    Image name: %s\n"), pnote->descdata);
14217       break;
14218     case NT_VMS_GSTNAM:
14219       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
14220       break;
14221     case NT_VMS_IMGID:
14222       printf (_("    Image id: %s\n"), pnote->descdata);
14223       break;
14224     case NT_VMS_LINKID:
14225       printf (_("    Linker id: %s\n"), pnote->descdata);
14226       break;
14227     default:
14228       break;
14229     }
14230   return 1;
14231 }
14232
14233 /* Note that by the ELF standard, the name field is already null byte
14234    terminated, and namesz includes the terminating null byte.
14235    I.E. the value of namesz for the name "FSF" is 4.
14236
14237    If the value of namesz is zero, there is no name present.  */
14238 static int
14239 process_note (Elf_Internal_Note * pnote)
14240 {
14241   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14242   const char * nt;
14243
14244   if (pnote->namesz == 0)
14245     /* If there is no note name, then use the default set of
14246        note type strings.  */
14247     nt = get_note_type (pnote->type);
14248
14249   else if (const_strneq (pnote->namedata, "GNU"))
14250     /* GNU-specific object file notes.  */
14251     nt = get_gnu_elf_note_type (pnote->type);
14252
14253   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14254     /* NetBSD-specific core file notes.  */
14255     nt = get_netbsd_elfcore_note_type (pnote->type);
14256
14257   else if (strneq (pnote->namedata, "SPU/", 4))
14258     {
14259       /* SPU-specific core file notes.  */
14260       nt = pnote->namedata + 4;
14261       name = "SPU";
14262     }
14263
14264   else if (const_strneq (pnote->namedata, "IPF/VMS"))
14265     /* VMS/ia64-specific file notes.  */
14266     nt = get_ia64_vms_note_type (pnote->type);
14267
14268   else if (const_strneq (pnote->namedata, "stapsdt"))
14269     nt = get_stapsdt_note_type (pnote->type);
14270
14271   else
14272     /* Don't recognize this note name; just use the default set of
14273        note type strings.  */
14274     nt = get_note_type (pnote->type);
14275
14276   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14277
14278   if (const_strneq (pnote->namedata, "IPF/VMS"))
14279     return print_ia64_vms_note (pnote);
14280   else if (const_strneq (pnote->namedata, "GNU"))
14281     return print_gnu_note (pnote);
14282   else if (const_strneq (pnote->namedata, "stapsdt"))
14283     return print_stapsdt_note (pnote);
14284   else if (const_strneq (pnote->namedata, "CORE"))
14285     return print_core_note (pnote);
14286   else
14287     return 1;
14288 }
14289
14290
14291 static int
14292 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14293 {
14294   Elf_External_Note * pnotes;
14295   Elf_External_Note * external;
14296   int res = 1;
14297
14298   if (length <= 0)
14299     return 0;
14300
14301   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14302                                            _("notes"));
14303   if (pnotes == NULL)
14304     return 0;
14305
14306   external = pnotes;
14307
14308   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14309           (unsigned long) offset, (unsigned long) length);
14310   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14311
14312   while ((char *) external < (char *) pnotes + length)
14313     {
14314       Elf_Internal_Note inote;
14315       size_t min_notesz;
14316       char *next;
14317       char * temp = NULL;
14318       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14319
14320       if (!is_ia64_vms ())
14321         {
14322           /* PR binutils/15191
14323              Make sure that there is enough data to read.  */
14324           min_notesz = offsetof (Elf_External_Note, name);
14325           if (data_remaining < min_notesz)
14326             {
14327               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14328                     (int) data_remaining);
14329               break;
14330             }
14331           inote.type     = BYTE_GET (external->type);
14332           inote.namesz   = BYTE_GET (external->namesz);
14333           inote.namedata = external->name;
14334           inote.descsz   = BYTE_GET (external->descsz);
14335           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14336           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14337           next = inote.descdata + align_power (inote.descsz, 2);
14338         }
14339       else
14340         {
14341           Elf64_External_VMS_Note *vms_external;
14342
14343           /* PR binutils/15191
14344              Make sure that there is enough data to read.  */
14345           min_notesz = offsetof (Elf64_External_VMS_Note, name);
14346           if (data_remaining < min_notesz)
14347             {
14348               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14349                     (int) data_remaining);
14350               break;
14351             }
14352
14353           vms_external = (Elf64_External_VMS_Note *) external;
14354           inote.type     = BYTE_GET (vms_external->type);
14355           inote.namesz   = BYTE_GET (vms_external->namesz);
14356           inote.namedata = vms_external->name;
14357           inote.descsz   = BYTE_GET (vms_external->descsz);
14358           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14359           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14360           next = inote.descdata + align_power (inote.descsz, 3);
14361         }
14362
14363       if (inote.descdata < (char *) external + min_notesz
14364           || next < (char *) external + min_notesz
14365           || data_remaining < (size_t)(next - (char *) external))
14366         {
14367           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14368                 (unsigned long) ((char *) external - (char *) pnotes));
14369           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14370                 inote.type, inote.namesz, inote.descsz);
14371           break;
14372         }
14373
14374       external = (Elf_External_Note *) next;
14375
14376       /* Verify that name is null terminated.  It appears that at least
14377          one version of Linux (RedHat 6.0) generates corefiles that don't
14378          comply with the ELF spec by failing to include the null byte in
14379          namesz.  */
14380       if (inote.namedata[inote.namesz - 1] != '\0')
14381         {
14382           temp = (char *) malloc (inote.namesz + 1);
14383
14384           if (temp == NULL)
14385             {
14386               error (_("Out of memory\n"));
14387               res = 0;
14388               break;
14389             }
14390
14391           strncpy (temp, inote.namedata, inote.namesz);
14392           temp[inote.namesz] = 0;
14393
14394           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
14395           inote.namedata = temp;
14396         }
14397
14398       res &= process_note (& inote);
14399
14400       if (temp != NULL)
14401         {
14402           free (temp);
14403           temp = NULL;
14404         }
14405     }
14406
14407   free (pnotes);
14408
14409   return res;
14410 }
14411
14412 static int
14413 process_corefile_note_segments (FILE * file)
14414 {
14415   Elf_Internal_Phdr * segment;
14416   unsigned int i;
14417   int res = 1;
14418
14419   if (! get_program_headers (file))
14420       return 0;
14421
14422   for (i = 0, segment = program_headers;
14423        i < elf_header.e_phnum;
14424        i++, segment++)
14425     {
14426       if (segment->p_type == PT_NOTE)
14427         res &= process_corefile_note_segment (file,
14428                                               (bfd_vma) segment->p_offset,
14429                                               (bfd_vma) segment->p_filesz);
14430     }
14431
14432   return res;
14433 }
14434
14435 static int
14436 process_note_sections (FILE * file)
14437 {
14438   Elf_Internal_Shdr * section;
14439   unsigned long i;
14440   int n = 0;
14441   int res = 1;
14442
14443   for (i = 0, section = section_headers;
14444        i < elf_header.e_shnum && section != NULL;
14445        i++, section++)
14446     if (section->sh_type == SHT_NOTE)
14447       {
14448         res &= process_corefile_note_segment (file,
14449                                               (bfd_vma) section->sh_offset,
14450                                               (bfd_vma) section->sh_size);
14451         n++;
14452       }
14453
14454   if (n == 0)
14455     /* Try processing NOTE segments instead.  */
14456     return process_corefile_note_segments (file);
14457
14458   return res;
14459 }
14460
14461 static int
14462 process_notes (FILE * file)
14463 {
14464   /* If we have not been asked to display the notes then do nothing.  */
14465   if (! do_notes)
14466     return 1;
14467
14468   if (elf_header.e_type != ET_CORE)
14469     return process_note_sections (file);
14470
14471   /* No program headers means no NOTE segment.  */
14472   if (elf_header.e_phnum > 0)
14473     return process_corefile_note_segments (file);
14474
14475   printf (_("No note segments present in the core file.\n"));
14476   return 1;
14477 }
14478
14479 static int
14480 process_arch_specific (FILE * file)
14481 {
14482   if (! do_arch)
14483     return 1;
14484
14485   switch (elf_header.e_machine)
14486     {
14487     case EM_ARM:
14488       return process_arm_specific (file);
14489     case EM_MIPS:
14490     case EM_MIPS_RS3_LE:
14491       return process_mips_specific (file);
14492       break;
14493     case EM_NDS32:
14494       return process_nds32_specific (file);
14495       break;
14496     case EM_PPC:
14497       return process_power_specific (file);
14498       break;
14499     case EM_SPARC:
14500     case EM_SPARC32PLUS:
14501     case EM_SPARCV9:
14502       return process_sparc_specific (file);
14503       break;
14504     case EM_TI_C6000:
14505       return process_tic6x_specific (file);
14506       break;
14507     case EM_MSP430:
14508       return process_msp430x_specific (file);
14509     default:
14510       break;
14511     }
14512   return 1;
14513 }
14514
14515 static int
14516 get_file_header (FILE * file)
14517 {
14518   /* Read in the identity array.  */
14519   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14520     return 0;
14521
14522   /* Determine how to read the rest of the header.  */
14523   switch (elf_header.e_ident[EI_DATA])
14524     {
14525     default: /* fall through */
14526     case ELFDATANONE: /* fall through */
14527     case ELFDATA2LSB:
14528       byte_get = byte_get_little_endian;
14529       byte_put = byte_put_little_endian;
14530       break;
14531     case ELFDATA2MSB:
14532       byte_get = byte_get_big_endian;
14533       byte_put = byte_put_big_endian;
14534       break;
14535     }
14536
14537   /* For now we only support 32 bit and 64 bit ELF files.  */
14538   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14539
14540   /* Read in the rest of the header.  */
14541   if (is_32bit_elf)
14542     {
14543       Elf32_External_Ehdr ehdr32;
14544
14545       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14546         return 0;
14547
14548       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
14549       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
14550       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
14551       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
14552       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
14553       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
14554       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
14555       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
14556       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14557       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
14558       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14559       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
14560       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
14561     }
14562   else
14563     {
14564       Elf64_External_Ehdr ehdr64;
14565
14566       /* If we have been compiled with sizeof (bfd_vma) == 4, then
14567          we will not be able to cope with the 64bit data found in
14568          64 ELF files.  Detect this now and abort before we start
14569          overwriting things.  */
14570       if (sizeof (bfd_vma) < 8)
14571         {
14572           error (_("This instance of readelf has been built without support for a\n\
14573 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14574           return 0;
14575         }
14576
14577       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14578         return 0;
14579
14580       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
14581       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
14582       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
14583       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
14584       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
14585       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
14586       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
14587       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
14588       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14589       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
14590       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14591       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
14592       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
14593     }
14594
14595   if (elf_header.e_shoff)
14596     {
14597       /* There may be some extensions in the first section header.  Don't
14598          bomb if we can't read it.  */
14599       if (is_32bit_elf)
14600         get_32bit_section_headers (file, TRUE);
14601       else
14602         get_64bit_section_headers (file, TRUE);
14603     }
14604
14605   return 1;
14606 }
14607
14608 /* Process one ELF object file according to the command line options.
14609    This file may actually be stored in an archive.  The file is
14610    positioned at the start of the ELF object.  */
14611
14612 static int
14613 process_object (char * file_name, FILE * file)
14614 {
14615   unsigned int i;
14616
14617   if (! get_file_header (file))
14618     {
14619       error (_("%s: Failed to read file header\n"), file_name);
14620       return 1;
14621     }
14622
14623   /* Initialise per file variables.  */
14624   for (i = ARRAY_SIZE (version_info); i--;)
14625     version_info[i] = 0;
14626
14627   for (i = ARRAY_SIZE (dynamic_info); i--;)
14628     dynamic_info[i] = 0;
14629   dynamic_info_DT_GNU_HASH = 0;
14630
14631   /* Process the file.  */
14632   if (show_name)
14633     printf (_("\nFile: %s\n"), file_name);
14634
14635   /* Initialise the dump_sects array from the cmdline_dump_sects array.
14636      Note we do this even if cmdline_dump_sects is empty because we
14637      must make sure that the dump_sets array is zeroed out before each
14638      object file is processed.  */
14639   if (num_dump_sects > num_cmdline_dump_sects)
14640     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14641
14642   if (num_cmdline_dump_sects > 0)
14643     {
14644       if (num_dump_sects == 0)
14645         /* A sneaky way of allocating the dump_sects array.  */
14646         request_dump_bynumber (num_cmdline_dump_sects, 0);
14647
14648       assert (num_dump_sects >= num_cmdline_dump_sects);
14649       memcpy (dump_sects, cmdline_dump_sects,
14650               num_cmdline_dump_sects * sizeof (* dump_sects));
14651     }
14652
14653   if (! process_file_header ())
14654     return 1;
14655
14656   if (! process_section_headers (file))
14657     {
14658       /* Without loaded section headers we cannot process lots of
14659          things.  */
14660       do_unwind = do_version = do_dump = do_arch = 0;
14661
14662       if (! do_using_dynamic)
14663         do_syms = do_dyn_syms = do_reloc = 0;
14664     }
14665
14666   if (! process_section_groups (file))
14667     {
14668       /* Without loaded section groups we cannot process unwind.  */
14669       do_unwind = 0;
14670     }
14671
14672   if (process_program_headers (file))
14673     process_dynamic_section (file);
14674
14675   process_relocs (file);
14676
14677   process_unwind (file);
14678
14679   process_symbol_table (file);
14680
14681   process_syminfo (file);
14682
14683   process_version_sections (file);
14684
14685   process_section_contents (file);
14686
14687   process_notes (file);
14688
14689   process_gnu_liblist (file);
14690
14691   process_arch_specific (file);
14692
14693   if (program_headers)
14694     {
14695       free (program_headers);
14696       program_headers = NULL;
14697     }
14698
14699   if (section_headers)
14700     {
14701       free (section_headers);
14702       section_headers = NULL;
14703     }
14704
14705   if (string_table)
14706     {
14707       free (string_table);
14708       string_table = NULL;
14709       string_table_length = 0;
14710     }
14711
14712   if (dynamic_strings)
14713     {
14714       free (dynamic_strings);
14715       dynamic_strings = NULL;
14716       dynamic_strings_length = 0;
14717     }
14718
14719   if (dynamic_symbols)
14720     {
14721       free (dynamic_symbols);
14722       dynamic_symbols = NULL;
14723       num_dynamic_syms = 0;
14724     }
14725
14726   if (dynamic_syminfo)
14727     {
14728       free (dynamic_syminfo);
14729       dynamic_syminfo = NULL;
14730     }
14731
14732   if (dynamic_section)
14733     {
14734       free (dynamic_section);
14735       dynamic_section = NULL;
14736     }
14737
14738   if (section_headers_groups)
14739     {
14740       free (section_headers_groups);
14741       section_headers_groups = NULL;
14742     }
14743
14744   if (section_groups)
14745     {
14746       struct group_list * g;
14747       struct group_list * next;
14748
14749       for (i = 0; i < group_count; i++)
14750         {
14751           for (g = section_groups [i].root; g != NULL; g = next)
14752             {
14753               next = g->next;
14754               free (g);
14755             }
14756         }
14757
14758       free (section_groups);
14759       section_groups = NULL;
14760     }
14761
14762   free_debug_memory ();
14763
14764   return 0;
14765 }
14766
14767 /* Process an ELF archive.
14768    On entry the file is positioned just after the ARMAG string.  */
14769
14770 static int
14771 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14772 {
14773   struct archive_info arch;
14774   struct archive_info nested_arch;
14775   size_t got;
14776   int ret;
14777
14778   show_name = 1;
14779
14780   /* The ARCH structure is used to hold information about this archive.  */
14781   arch.file_name = NULL;
14782   arch.file = NULL;
14783   arch.index_array = NULL;
14784   arch.sym_table = NULL;
14785   arch.longnames = NULL;
14786
14787   /* The NESTED_ARCH structure is used as a single-item cache of information
14788      about a nested archive (when members of a thin archive reside within
14789      another regular archive file).  */
14790   nested_arch.file_name = NULL;
14791   nested_arch.file = NULL;
14792   nested_arch.index_array = NULL;
14793   nested_arch.sym_table = NULL;
14794   nested_arch.longnames = NULL;
14795
14796   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14797     {
14798       ret = 1;
14799       goto out;
14800     }
14801
14802   if (do_archive_index)
14803     {
14804       if (arch.sym_table == NULL)
14805         error (_("%s: unable to dump the index as none was found\n"), file_name);
14806       else
14807         {
14808           unsigned int i, l;
14809           unsigned long current_pos;
14810
14811           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14812                   file_name, (long) arch.index_num, arch.sym_size);
14813           current_pos = ftell (file);
14814
14815           for (i = l = 0; i < arch.index_num; i++)
14816             {
14817               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14818                 {
14819                   char * member_name;
14820
14821                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14822
14823                   if (member_name != NULL)
14824                     {
14825                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14826
14827                       if (qualified_name != NULL)
14828                         {
14829                           printf (_("Contents of binary %s at offset "), qualified_name);
14830                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14831                           putchar ('\n');
14832                           free (qualified_name);
14833                         }
14834                     }
14835                 }
14836
14837               if (l >= arch.sym_size)
14838                 {
14839                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14840                          file_name);
14841                   break;
14842                 }
14843               printf ("\t%s\n", arch.sym_table + l);
14844               l += strlen (arch.sym_table + l) + 1;
14845             }
14846
14847           if (arch.uses_64bit_indicies)
14848             l = (l + 7) & ~ 7;
14849           else
14850             l += l & 1;
14851
14852           if (l < arch.sym_size)
14853             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14854                    file_name, arch.sym_size - l);
14855
14856           if (fseek (file, current_pos, SEEK_SET) != 0)
14857             {
14858               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14859               ret = 1;
14860               goto out;
14861             }
14862         }
14863
14864       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14865           && !do_segments && !do_header && !do_dump && !do_version
14866           && !do_histogram && !do_debugging && !do_arch && !do_notes
14867           && !do_section_groups && !do_dyn_syms)
14868         {
14869           ret = 0; /* Archive index only.  */
14870           goto out;
14871         }
14872     }
14873
14874   ret = 0;
14875
14876   while (1)
14877     {
14878       char * name;
14879       size_t namelen;
14880       char * qualified_name;
14881
14882       /* Read the next archive header.  */
14883       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14884         {
14885           error (_("%s: failed to seek to next archive header\n"), file_name);
14886           return 1;
14887         }
14888       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14889       if (got != sizeof arch.arhdr)
14890         {
14891           if (got == 0)
14892             break;
14893           error (_("%s: failed to read archive header\n"), file_name);
14894           ret = 1;
14895           break;
14896         }
14897       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14898         {
14899           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14900           ret = 1;
14901           break;
14902         }
14903
14904       arch.next_arhdr_offset += sizeof arch.arhdr;
14905
14906       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14907       if (archive_file_size & 01)
14908         ++archive_file_size;
14909
14910       name = get_archive_member_name (&arch, &nested_arch);
14911       if (name == NULL)
14912         {
14913           error (_("%s: bad archive file name\n"), file_name);
14914           ret = 1;
14915           break;
14916         }
14917       namelen = strlen (name);
14918
14919       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14920       if (qualified_name == NULL)
14921         {
14922           error (_("%s: bad archive file name\n"), file_name);
14923           ret = 1;
14924           break;
14925         }
14926
14927       if (is_thin_archive && arch.nested_member_origin == 0)
14928         {
14929           /* This is a proxy for an external member of a thin archive.  */
14930           FILE * member_file;
14931           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14932           if (member_file_name == NULL)
14933             {
14934               ret = 1;
14935               break;
14936             }
14937
14938           member_file = fopen (member_file_name, "rb");
14939           if (member_file == NULL)
14940             {
14941               error (_("Input file '%s' is not readable.\n"), member_file_name);
14942               free (member_file_name);
14943               ret = 1;
14944               break;
14945             }
14946
14947           archive_file_offset = arch.nested_member_origin;
14948
14949           ret |= process_object (qualified_name, member_file);
14950
14951           fclose (member_file);
14952           free (member_file_name);
14953         }
14954       else if (is_thin_archive)
14955         {
14956           /* PR 15140: Allow for corrupt thin archives.  */
14957           if (nested_arch.file == NULL)
14958             {
14959               error (_("%s: contains corrupt thin archive: %s\n"),
14960                      file_name, name);
14961               ret = 1;
14962               break;
14963             }
14964
14965           /* This is a proxy for a member of a nested archive.  */
14966           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14967
14968           /* The nested archive file will have been opened and setup by
14969              get_archive_member_name.  */
14970           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14971             {
14972               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14973               ret = 1;
14974               break;
14975             }
14976
14977           ret |= process_object (qualified_name, nested_arch.file);
14978         }
14979       else
14980         {
14981           archive_file_offset = arch.next_arhdr_offset;
14982           arch.next_arhdr_offset += archive_file_size;
14983
14984           ret |= process_object (qualified_name, file);
14985         }
14986
14987       if (dump_sects != NULL)
14988         {
14989           free (dump_sects);
14990           dump_sects = NULL;
14991           num_dump_sects = 0;
14992         }
14993
14994       free (qualified_name);
14995     }
14996
14997  out:
14998   if (nested_arch.file != NULL)
14999     fclose (nested_arch.file);
15000   release_archive (&nested_arch);
15001   release_archive (&arch);
15002
15003   return ret;
15004 }
15005
15006 static int
15007 process_file (char * file_name)
15008 {
15009   FILE * file;
15010   struct stat statbuf;
15011   char armag[SARMAG];
15012   int ret;
15013
15014   if (stat (file_name, &statbuf) < 0)
15015     {
15016       if (errno == ENOENT)
15017         error (_("'%s': No such file\n"), file_name);
15018       else
15019         error (_("Could not locate '%s'.  System error message: %s\n"),
15020                file_name, strerror (errno));
15021       return 1;
15022     }
15023
15024   if (! S_ISREG (statbuf.st_mode))
15025     {
15026       error (_("'%s' is not an ordinary file\n"), file_name);
15027       return 1;
15028     }
15029
15030   file = fopen (file_name, "rb");
15031   if (file == NULL)
15032     {
15033       error (_("Input file '%s' is not readable.\n"), file_name);
15034       return 1;
15035     }
15036
15037   if (fread (armag, SARMAG, 1, file) != 1)
15038     {
15039       error (_("%s: Failed to read file's magic number\n"), file_name);
15040       fclose (file);
15041       return 1;
15042     }
15043
15044   current_file_size = (bfd_size_type) statbuf.st_size;
15045
15046   if (memcmp (armag, ARMAG, SARMAG) == 0)
15047     ret = process_archive (file_name, file, FALSE);
15048   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15049     ret = process_archive (file_name, file, TRUE);
15050   else
15051     {
15052       if (do_archive_index)
15053         error (_("File %s is not an archive so its index cannot be displayed.\n"),
15054                file_name);
15055
15056       rewind (file);
15057       archive_file_size = archive_file_offset = 0;
15058       ret = process_object (file_name, file);
15059     }
15060
15061   fclose (file);
15062
15063   current_file_size = 0;
15064   return ret;
15065 }
15066
15067 #ifdef SUPPORT_DISASSEMBLY
15068 /* Needed by the i386 disassembler.  For extra credit, someone could
15069    fix this so that we insert symbolic addresses here, esp for GOT/PLT
15070    symbols.  */
15071
15072 void
15073 print_address (unsigned int addr, FILE * outfile)
15074 {
15075   fprintf (outfile,"0x%8.8x", addr);
15076 }
15077
15078 /* Needed by the i386 disassembler.  */
15079 void
15080 db_task_printsym (unsigned int addr)
15081 {
15082   print_address (addr, stderr);
15083 }
15084 #endif
15085
15086 int
15087 main (int argc, char ** argv)
15088 {
15089   int err;
15090
15091 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15092   setlocale (LC_MESSAGES, "");
15093 #endif
15094 #if defined (HAVE_SETLOCALE)
15095   setlocale (LC_CTYPE, "");
15096 #endif
15097   bindtextdomain (PACKAGE, LOCALEDIR);
15098   textdomain (PACKAGE);
15099
15100   expandargv (&argc, &argv);
15101
15102   parse_args (argc, argv);
15103
15104   if (num_dump_sects > 0)
15105     {
15106       /* Make a copy of the dump_sects array.  */
15107       cmdline_dump_sects = (dump_type *)
15108           malloc (num_dump_sects * sizeof (* dump_sects));
15109       if (cmdline_dump_sects == NULL)
15110         error (_("Out of memory allocating dump request table.\n"));
15111       else
15112         {
15113           memcpy (cmdline_dump_sects, dump_sects,
15114                   num_dump_sects * sizeof (* dump_sects));
15115           num_cmdline_dump_sects = num_dump_sects;
15116         }
15117     }
15118
15119   if (optind < (argc - 1))
15120     show_name = 1;
15121
15122   err = 0;
15123   while (optind < argc)
15124     err |= process_file (argv[optind++]);
15125
15126   if (dump_sects != NULL)
15127     free (dump_sects);
15128   if (cmdline_dump_sects != NULL)
15129     free (cmdline_dump_sects);
15130
15131   return err;
15132 }