binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2015 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or1k.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/visium.h"
 152 #include "elf/x86-64.h"
 153 #include "elf/xc16x.h"
 154 #include "elf/xgate.h"
 155 #include "elf/xstormy16.h"
 156 #include "elf/xtensa.h"
 157
 158 #include "getopt.h"
 159 #include "libiberty.h"
 160 #include "safe-ctype.h"
 161 #include "filenames.h"
 162
 163 #ifndef offsetof
 164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 165 #endif
 166
 167 char * program_name = "readelf";
 168 static unsigned long archive_file_offset;
 169 static unsigned long archive_file_size;
 170 static bfd_size_type current_file_size;
 171 static unsigned long dynamic_addr;
 172 static bfd_size_type dynamic_size;
 173 static size_t dynamic_nent;
 174 static char * dynamic_strings;
 175 static unsigned long dynamic_strings_length;
 176 static char * string_table;
 177 static unsigned long string_table_length;
 178 static unsigned long num_dynamic_syms;
 179 static Elf_Internal_Sym * dynamic_symbols;
 180 static Elf_Internal_Syminfo * dynamic_syminfo;
 181 static unsigned long dynamic_syminfo_offset;
 182 static unsigned int dynamic_syminfo_nent;
 183 static char program_interpreter[PATH_MAX];
 184 static bfd_vma dynamic_info[DT_ENCODING];
 185 static bfd_vma dynamic_info_DT_GNU_HASH;
 186 static bfd_vma version_info[16];
 187 static Elf_Internal_Ehdr elf_header;
 188 static Elf_Internal_Shdr * section_headers;
 189 static Elf_Internal_Phdr * program_headers;
 190 static Elf_Internal_Dyn *  dynamic_section;
 191 static Elf_Internal_Shdr * symtab_shndx_hdr;
 192 static int show_name;
 193 static int do_dynamic;
 194 static int do_syms;
 195 static int do_dyn_syms;
 196 static int do_reloc;
 197 static int do_sections;
 198 static int do_section_groups;
 199 static int do_section_details;
 200 static int do_segments;
 201 static int do_unwind;
 202 static int do_using_dynamic;
 203 static int do_header;
 204 static int do_dump;
 205 static int do_version;
 206 static int do_histogram;
 207 static int do_debugging;
 208 static int do_arch;
 209 static int do_notes;
 210 static int do_archive_index;
 211 static int is_32bit_elf;
 212 static int decompress_dumps;
 213
 214 struct group_list
 215 {
 216   struct group_list * next;
 217   unsigned int section_index;
 218 };
 219
 220 struct group
 221 {
 222   struct group_list * root;
 223   unsigned int group_index;
 224 };
 225
 226 static size_t group_count;
 227 static struct group * section_groups;
 228 static struct group ** section_headers_groups;
 229
 230
 231 /* Flag bits indicating particular types of dump.  */
 232 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 233 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 234 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 235 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 236 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 237
 238 typedef unsigned char dump_type;
 239
 240 /* A linked list of the section names for which dumps were requested.  */
 241 struct dump_list_entry
 242 {
 243   char * name;
 244   dump_type type;
 245   struct dump_list_entry * next;
 246 };
 247 static struct dump_list_entry * dump_sects_byname;
 248
 249 /* A dynamic array of flags indicating for which sections a dump
 250    has been requested via command line switches.  */
 251 static dump_type *   cmdline_dump_sects = NULL;
 252 static unsigned int  num_cmdline_dump_sects = 0;
 253
 254 /* A dynamic array of flags indicating for which sections a dump of
 255    some kind has been requested.  It is reset on a per-object file
 256    basis and then initialised from the cmdline_dump_sects array,
 257    the results of interpreting the -w switch, and the
 258    dump_sects_byname list.  */
 259 static dump_type *   dump_sects = NULL;
 260 static unsigned int  num_dump_sects = 0;
 261
 262
 263 /* How to print a vma value.  */
 264 typedef enum print_mode
 265 {
 266   HEX,
 267   DEC,
 268   DEC_5,
 269   UNSIGNED,
 270   PREFIX_HEX,
 271   FULL_HEX,
 272   LONG_HEX
 273 }
 274 print_mode;
 275
 276 /* Versioned symbol info.  */
 277 enum versioned_symbol_info
 278 {
 279   symbol_undefined,
 280   symbol_hidden,
 281   symbol_public
 282 };
 283
 284 static const char *get_symbol_version_string
 285   (FILE *file, int is_dynsym, const char *strtab,
 286    unsigned long int strtab_size, unsigned int si,
 287    Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
 288    unsigned short *vna_other);
 289
 290 #define UNKNOWN -1
 291
 292 #define SECTION_NAME(X)                                         \
 293   ((X) == NULL ? _("<none>")                                    \
 294    : string_table == NULL ? _("<no-name>")                      \
 295    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 296   : string_table + (X)->sh_name))
 297
 298 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 299
 300 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 301   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 302    : get_64bit_elf_symbols (file, section, sym_count))
 303
 304 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 305 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 306    already been called and verified that the string exists.  */
 307 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 308
 309 #define REMOVE_ARCH_BITS(ADDR)                  \
 310   do                                            \
 311     {                                           \
 312       if (elf_header.e_machine == EM_ARM)       \
 313         (ADDR) &= ~1;                           \
 314     }                                           \
 315   while (0)
 316 \f
 317 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 318    the offset of the current archive member, if we are examining an archive.
 319    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 320    using malloc and fill that.  In either case return the pointer to the start of
 321    the retrieved data or NULL if something went wrong.  If something does go wrong
 322    and REASON is not NULL then emit an error message using REASON as part of the
 323    context.  */
 324
 325 static void *
 326 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 327           bfd_size_type nmemb, const char * reason)
 328 {
 329   void * mvar;
 330   bfd_size_type amt = size * nmemb;
 331
 332   if (size == 0 || nmemb == 0)
 333     return NULL;
 334
 335   /* If the size_t type is smaller than the bfd_size_type, eg because
 336      you are building a 32-bit tool on a 64-bit host, then make sure
 337      that when the sizes are cast to (size_t) no information is lost.  */
 338   if (sizeof (size_t) < sizeof (bfd_size_type)
 339       && (   (bfd_size_type) ((size_t) size) != size
 340           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 341     {
 342       if (reason)
 343         error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 344                (unsigned long long) nmemb, (unsigned long long) size, reason);
 345       return NULL;
 346     }
 347
 348   /* Check for size overflow.  */
 349   if (amt < nmemb)
 350     {
 351       if (reason)
 352         error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 353                (unsigned long long) nmemb, (unsigned long long) size, reason);
 354       return NULL;
 355     }
 356
 357   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 358      attempting to allocate memory when the read is bound to fail.  */
 359   if (amt > current_file_size
 360       || offset + archive_file_offset + amt > current_file_size)
 361     {
 362       if (reason)
 363         error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
 364                (unsigned long long) amt, reason);
 365       return NULL;
 366     }
 367
 368   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 369     {
 370       if (reason)
 371         error (_("Unable to seek to 0x%lx for %s\n"),
 372                (unsigned long) archive_file_offset + offset, reason);
 373       return NULL;
 374     }
 375
 376   mvar = var;
 377   if (mvar == NULL)
 378     {
 379       /* Check for overflow.  */
 380       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 381         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 382         mvar = malloc ((size_t) amt + 1);
 383
 384       if (mvar == NULL)
 385         {
 386           if (reason)
 387             error (_("Out of memory allocating 0x%llx bytes for %s\n"),
 388                    (unsigned long long) amt, reason);
 389           return NULL;
 390         }
 391
 392       ((char *) mvar)[amt] = '\0';
 393     }
 394
 395   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 396     {
 397       if (reason)
 398         error (_("Unable to read in 0x%llx bytes of %s\n"),
 399                (unsigned long long) amt, reason);
 400       if (mvar != var)
 401         free (mvar);
 402       return NULL;
 403     }
 404
 405   return mvar;
 406 }
 407
 408 /* Print a VMA value.  */
 409
 410 static int
 411 print_vma (bfd_vma vma, print_mode mode)
 412 {
 413   int nc = 0;
 414
 415   switch (mode)
 416     {
 417     case FULL_HEX:
 418       nc = printf ("0x");
 419       /* Drop through.  */
 420
 421     case LONG_HEX:
 422 #ifdef BFD64
 423       if (is_32bit_elf)
 424         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 425 #endif
 426       printf_vma (vma);
 427       return nc + 16;
 428
 429     case DEC_5:
 430       if (vma <= 99999)
 431         return printf ("%5" BFD_VMA_FMT "d", vma);
 432       /* Drop through.  */
 433
 434     case PREFIX_HEX:
 435       nc = printf ("0x");
 436       /* Drop through.  */
 437
 438     case HEX:
 439       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 440
 441     case DEC:
 442       return printf ("%" BFD_VMA_FMT "d", vma);
 443
 444     case UNSIGNED:
 445       return printf ("%" BFD_VMA_FMT "u", vma);
 446     }
 447   return 0;
 448 }
 449
 450 /* Display a symbol on stdout.  Handles the display of control characters and
 451    multibye characters (assuming the host environment supports them).
 452
 453    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 454
 455    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 456    padding as necessary.
 457
 458    Returns the number of emitted characters.  */
 459
 460 static unsigned int
 461 print_symbol (int width, const char *symbol)
 462 {
 463   bfd_boolean extra_padding = FALSE;
 464   int num_printed = 0;
 465 #ifdef HAVE_MBSTATE_T
 466   mbstate_t state;
 467 #endif
 468   int width_remaining;
 469
 470   if (width < 0)
 471     {
 472       /* Keep the width positive.  This also helps.  */
 473       width = - width;
 474       extra_padding = TRUE;
 475     }
 476   assert (width != 0);
 477
 478   if (do_wide)
 479     /* Set the remaining width to a very large value.
 480        This simplifies the code below.  */
 481     width_remaining = INT_MAX;
 482   else
 483     width_remaining = width;
 484
 485 #ifdef HAVE_MBSTATE_T
 486   /* Initialise the multibyte conversion state.  */
 487   memset (& state, 0, sizeof (state));
 488 #endif
 489
 490   while (width_remaining)
 491     {
 492       size_t  n;
 493       const char c = *symbol++;
 494
 495       if (c == 0)
 496         break;
 497
 498       /* Do not print control characters directly as they can affect terminal
 499          settings.  Such characters usually appear in the names generated
 500          by the assembler for local labels.  */
 501       if (ISCNTRL (c))
 502         {
 503           if (width_remaining < 2)
 504             break;
 505
 506           printf ("^%c", c + 0x40);
 507           width_remaining -= 2;
 508           num_printed += 2;
 509         }
 510       else if (ISPRINT (c))
 511         {
 512           putchar (c);
 513           width_remaining --;
 514           num_printed ++;
 515         }
 516       else
 517         {
 518 #ifdef HAVE_MBSTATE_T
 519           wchar_t w;
 520 #endif
 521           /* Let printf do the hard work of displaying multibyte characters.  */
 522           printf ("%.1s", symbol - 1);
 523           width_remaining --;
 524           num_printed ++;
 525
 526 #ifdef HAVE_MBSTATE_T
 527           /* Try to find out how many bytes made up the character that was
 528              just printed.  Advance the symbol pointer past the bytes that
 529              were displayed.  */
 530           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 531 #else
 532           n = 1;
 533 #endif
 534           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 535             symbol += (n - 1);
 536         }
 537     }
 538
 539   if (extra_padding && num_printed < width)
 540     {
 541       /* Fill in the remaining spaces.  */
 542       printf ("%-*s", width - num_printed, " ");
 543       num_printed = width;
 544     }
 545
 546   return num_printed;
 547 }
 548
 549 /* Returns a pointer to a static buffer containing a  printable version of
 550    the given section's name.  Like print_symbol, except that it does not try
 551    to print multibyte characters, it just interprets them as hex values.  */
 552
 553 static const char *
 554 printable_section_name (const Elf_Internal_Shdr * sec)
 555 {
 556 #define MAX_PRINT_SEC_NAME_LEN 128
 557   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 558   const char * name = SECTION_NAME (sec);
 559   char *       buf = sec_name_buf;
 560   char         c;
 561   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 562
 563   while ((c = * name ++) != 0)
 564     {
 565       if (ISCNTRL (c))
 566         {
 567           if (remaining < 2)
 568             break;
 569
 570           * buf ++ = '^';
 571           * buf ++ = c + 0x40;
 572           remaining -= 2;
 573         }
 574       else if (ISPRINT (c))
 575         {
 576           * buf ++ = c;
 577           remaining -= 1;
 578         }
 579       else
 580         {
 581           static char hex[17] = "0123456789ABCDEF";
 582
 583           if (remaining < 4)
 584             break;
 585           * buf ++ = '<';
 586           * buf ++ = hex[(c & 0xf0) >> 4];
 587           * buf ++ = hex[c & 0x0f];
 588           * buf ++ = '>';
 589           remaining -= 4;
 590         }
 591
 592       if (remaining == 0)
 593         break;
 594     }
 595
 596   * buf = 0;
 597   return sec_name_buf;
 598 }
 599
 600 static const char *
 601 printable_section_name_from_index (unsigned long ndx)
 602 {
 603   if (ndx >= elf_header.e_shnum)
 604     return _("<corrupt>");
 605
 606   return printable_section_name (section_headers + ndx);
 607 }
 608
 609 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 610
 611 static Elf_Internal_Shdr *
 612 find_section (const char * name)
 613 {
 614   unsigned int i;
 615
 616   for (i = 0; i < elf_header.e_shnum; i++)
 617     if (streq (SECTION_NAME (section_headers + i), name))
 618       return section_headers + i;
 619
 620   return NULL;
 621 }
 622
 623 /* Return a pointer to a section containing ADDR, or NULL if no such
 624    section exists.  */
 625
 626 static Elf_Internal_Shdr *
 627 find_section_by_address (bfd_vma addr)
 628 {
 629   unsigned int i;
 630
 631   for (i = 0; i < elf_header.e_shnum; i++)
 632     {
 633       Elf_Internal_Shdr *sec = section_headers + i;
 634       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 635         return sec;
 636     }
 637
 638   return NULL;
 639 }
 640
 641 static Elf_Internal_Shdr *
 642 find_section_by_type (unsigned int type)
 643 {
 644   unsigned int i;
 645
 646   for (i = 0; i < elf_header.e_shnum; i++)
 647     {
 648       Elf_Internal_Shdr *sec = section_headers + i;
 649       if (sec->sh_type == type)
 650         return sec;
 651     }
 652
 653   return NULL;
 654 }
 655
 656 /* Return a pointer to section NAME, or NULL if no such section exists,
 657    restricted to the list of sections given in SET.  */
 658
 659 static Elf_Internal_Shdr *
 660 find_section_in_set (const char * name, unsigned int * set)
 661 {
 662   unsigned int i;
 663
 664   if (set != NULL)
 665     {
 666       while ((i = *set++) > 0)
 667         if (streq (SECTION_NAME (section_headers + i), name))
 668           return section_headers + i;
 669     }
 670
 671   return find_section (name);
 672 }
 673
 674 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 675    bytes read.  */
 676
 677 static inline unsigned long
 678 read_uleb128 (unsigned char *data,
 679               unsigned int *length_return,
 680               const unsigned char * const end)
 681 {
 682   return read_leb128 (data, length_return, FALSE, end);
 683 }
 684
 685 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 686    This OS has so many departures from the ELF standard that we test it at
 687    many places.  */
 688
 689 static inline int
 690 is_ia64_vms (void)
 691 {
 692   return elf_header.e_machine == EM_IA_64
 693     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 694 }
 695
 696 /* Guess the relocation size commonly used by the specific machines.  */
 697
 698 static int
 699 guess_is_rela (unsigned int e_machine)
 700 {
 701   switch (e_machine)
 702     {
 703       /* Targets that use REL relocations.  */
 704     case EM_386:
 705     case EM_IAMCU:
 706     case EM_960:
 707     case EM_ARM:
 708     case EM_D10V:
 709     case EM_CYGNUS_D10V:
 710     case EM_DLX:
 711     case EM_MIPS:
 712     case EM_MIPS_RS3_LE:
 713     case EM_CYGNUS_M32R:
 714     case EM_SCORE:
 715     case EM_XGATE:
 716       return FALSE;
 717
 718       /* Targets that use RELA relocations.  */
 719     case EM_68K:
 720     case EM_860:
 721     case EM_AARCH64:
 722     case EM_ADAPTEVA_EPIPHANY:
 723     case EM_ALPHA:
 724     case EM_ALTERA_NIOS2:
 725     case EM_AVR:
 726     case EM_AVR_OLD:
 727     case EM_BLACKFIN:
 728     case EM_CR16:
 729     case EM_CRIS:
 730     case EM_CRX:
 731     case EM_D30V:
 732     case EM_CYGNUS_D30V:
 733     case EM_FR30:
 734     case EM_FT32:
 735     case EM_CYGNUS_FR30:
 736     case EM_CYGNUS_FRV:
 737     case EM_H8S:
 738     case EM_H8_300:
 739     case EM_H8_300H:
 740     case EM_IA_64:
 741     case EM_IP2K:
 742     case EM_IP2K_OLD:
 743     case EM_IQ2000:
 744     case EM_LATTICEMICO32:
 745     case EM_M32C_OLD:
 746     case EM_M32C:
 747     case EM_M32R:
 748     case EM_MCORE:
 749     case EM_CYGNUS_MEP:
 750     case EM_METAG:
 751     case EM_MMIX:
 752     case EM_MN10200:
 753     case EM_CYGNUS_MN10200:
 754     case EM_MN10300:
 755     case EM_CYGNUS_MN10300:
 756     case EM_MOXIE:
 757     case EM_MSP430:
 758     case EM_MSP430_OLD:
 759     case EM_MT:
 760     case EM_NDS32:
 761     case EM_NIOS32:
 762     case EM_OR1K:
 763     case EM_PPC64:
 764     case EM_PPC:
 765     case EM_RL78:
 766     case EM_RX:
 767     case EM_S390:
 768     case EM_S390_OLD:
 769     case EM_SH:
 770     case EM_SPARC:
 771     case EM_SPARC32PLUS:
 772     case EM_SPARCV9:
 773     case EM_SPU:
 774     case EM_TI_C6000:
 775     case EM_TILEGX:
 776     case EM_TILEPRO:
 777     case EM_V800:
 778     case EM_V850:
 779     case EM_CYGNUS_V850:
 780     case EM_VAX:
 781     case EM_VISIUM:
 782     case EM_X86_64:
 783     case EM_L1OM:
 784     case EM_K1OM:
 785     case EM_XSTORMY16:
 786     case EM_XTENSA:
 787     case EM_XTENSA_OLD:
 788     case EM_MICROBLAZE:
 789     case EM_MICROBLAZE_OLD:
 790       return TRUE;
 791
 792     case EM_68HC05:
 793     case EM_68HC08:
 794     case EM_68HC11:
 795     case EM_68HC16:
 796     case EM_FX66:
 797     case EM_ME16:
 798     case EM_MMA:
 799     case EM_NCPU:
 800     case EM_NDR1:
 801     case EM_PCP:
 802     case EM_ST100:
 803     case EM_ST19:
 804     case EM_ST7:
 805     case EM_ST9PLUS:
 806     case EM_STARCORE:
 807     case EM_SVX:
 808     case EM_TINYJ:
 809     default:
 810       warn (_("Don't know about relocations on this machine architecture\n"));
 811       return FALSE;
 812     }
 813 }
 814
 815 static int
 816 slurp_rela_relocs (FILE * file,
 817                    unsigned long rel_offset,
 818                    unsigned long rel_size,
 819                    Elf_Internal_Rela ** relasp,
 820                    unsigned long * nrelasp)
 821 {
 822   Elf_Internal_Rela * relas;
 823   size_t nrelas;
 824   unsigned int i;
 825
 826   if (is_32bit_elf)
 827     {
 828       Elf32_External_Rela * erelas;
 829
 830       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 831                                                  rel_size, _("32-bit relocation data"));
 832       if (!erelas)
 833         return 0;
 834
 835       nrelas = rel_size / sizeof (Elf32_External_Rela);
 836
 837       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 838                                              sizeof (Elf_Internal_Rela));
 839
 840       if (relas == NULL)
 841         {
 842           free (erelas);
 843           error (_("out of memory parsing relocs\n"));
 844           return 0;
 845         }
 846
 847       for (i = 0; i < nrelas; i++)
 848         {
 849           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 850           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 851           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 852         }
 853
 854       free (erelas);
 855     }
 856   else
 857     {
 858       Elf64_External_Rela * erelas;
 859
 860       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 861                                                  rel_size, _("64-bit relocation data"));
 862       if (!erelas)
 863         return 0;
 864
 865       nrelas = rel_size / sizeof (Elf64_External_Rela);
 866
 867       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 868                                              sizeof (Elf_Internal_Rela));
 869
 870       if (relas == NULL)
 871         {
 872           free (erelas);
 873           error (_("out of memory parsing relocs\n"));
 874           return 0;
 875         }
 876
 877       for (i = 0; i < nrelas; i++)
 878         {
 879           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 880           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 881           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 882
 883           /* The #ifdef BFD64 below is to prevent a compile time
 884              warning.  We know that if we do not have a 64 bit data
 885              type that we will never execute this code anyway.  */
 886 #ifdef BFD64
 887           if (elf_header.e_machine == EM_MIPS
 888               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 889             {
 890               /* In little-endian objects, r_info isn't really a
 891                  64-bit little-endian value: it has a 32-bit
 892                  little-endian symbol index followed by four
 893                  individual byte fields.  Reorder INFO
 894                  accordingly.  */
 895               bfd_vma inf = relas[i].r_info;
 896               inf = (((inf & 0xffffffff) << 32)
 897                       | ((inf >> 56) & 0xff)
 898                       | ((inf >> 40) & 0xff00)
 899                       | ((inf >> 24) & 0xff0000)
 900                       | ((inf >> 8) & 0xff000000));
 901               relas[i].r_info = inf;
 902             }
 903 #endif /* BFD64 */
 904         }
 905
 906       free (erelas);
 907     }
 908   *relasp = relas;
 909   *nrelasp = nrelas;
 910   return 1;
 911 }
 912
 913 static int
 914 slurp_rel_relocs (FILE * file,
 915                   unsigned long rel_offset,
 916                   unsigned long rel_size,
 917                   Elf_Internal_Rela ** relsp,
 918                   unsigned long * nrelsp)
 919 {
 920   Elf_Internal_Rela * rels;
 921   size_t nrels;
 922   unsigned int i;
 923
 924   if (is_32bit_elf)
 925     {
 926       Elf32_External_Rel * erels;
 927
 928       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 929                                                rel_size, _("32-bit relocation data"));
 930       if (!erels)
 931         return 0;
 932
 933       nrels = rel_size / sizeof (Elf32_External_Rel);
 934
 935       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 936
 937       if (rels == NULL)
 938         {
 939           free (erels);
 940           error (_("out of memory parsing relocs\n"));
 941           return 0;
 942         }
 943
 944       for (i = 0; i < nrels; i++)
 945         {
 946           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 947           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 948           rels[i].r_addend = 0;
 949         }
 950
 951       free (erels);
 952     }
 953   else
 954     {
 955       Elf64_External_Rel * erels;
 956
 957       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 958                                                rel_size, _("64-bit relocation data"));
 959       if (!erels)
 960         return 0;
 961
 962       nrels = rel_size / sizeof (Elf64_External_Rel);
 963
 964       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 965
 966       if (rels == NULL)
 967         {
 968           free (erels);
 969           error (_("out of memory parsing relocs\n"));
 970           return 0;
 971         }
 972
 973       for (i = 0; i < nrels; i++)
 974         {
 975           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 976           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 977           rels[i].r_addend = 0;
 978
 979           /* The #ifdef BFD64 below is to prevent a compile time
 980              warning.  We know that if we do not have a 64 bit data
 981              type that we will never execute this code anyway.  */
 982 #ifdef BFD64
 983           if (elf_header.e_machine == EM_MIPS
 984               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 985             {
 986               /* In little-endian objects, r_info isn't really a
 987                  64-bit little-endian value: it has a 32-bit
 988                  little-endian symbol index followed by four
 989                  individual byte fields.  Reorder INFO
 990                  accordingly.  */
 991               bfd_vma inf = rels[i].r_info;
 992               inf = (((inf & 0xffffffff) << 32)
 993                      | ((inf >> 56) & 0xff)
 994                      | ((inf >> 40) & 0xff00)
 995                      | ((inf >> 24) & 0xff0000)
 996                      | ((inf >> 8) & 0xff000000));
 997               rels[i].r_info = inf;
 998             }
 999 #endif /* BFD64 */
1000         }
1001
1002       free (erels);
1003     }
1004   *relsp = rels;
1005   *nrelsp = nrels;
1006   return 1;
1007 }
1008
1009 /* Returns the reloc type extracted from the reloc info field.  */
1010
1011 static unsigned int
1012 get_reloc_type (bfd_vma reloc_info)
1013 {
1014   if (is_32bit_elf)
1015     return ELF32_R_TYPE (reloc_info);
1016
1017   switch (elf_header.e_machine)
1018     {
1019     case EM_MIPS:
1020       /* Note: We assume that reloc_info has already been adjusted for us.  */
1021       return ELF64_MIPS_R_TYPE (reloc_info);
1022
1023     case EM_SPARCV9:
1024       return ELF64_R_TYPE_ID (reloc_info);
1025
1026     default:
1027       return ELF64_R_TYPE (reloc_info);
1028     }
1029 }
1030
1031 /* Return the symbol index extracted from the reloc info field.  */
1032
1033 static bfd_vma
1034 get_reloc_symindex (bfd_vma reloc_info)
1035 {
1036   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1037 }
1038
1039 static inline bfd_boolean
1040 uses_msp430x_relocs (void)
1041 {
1042   return
1043     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1044     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1045     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1046         /* TI compiler uses ELFOSABI_NONE.  */
1047         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1048 }
1049
1050 /* Display the contents of the relocation data found at the specified
1051    offset.  */
1052
1053 static void
1054 dump_relocations (FILE * file,
1055                   unsigned long rel_offset,
1056                   unsigned long rel_size,
1057                   Elf_Internal_Sym * symtab,
1058                   unsigned long nsyms,
1059                   char * strtab,
1060                   unsigned long strtablen,
1061                   int is_rela,
1062                   int is_dynsym)
1063 {
1064   unsigned int i;
1065   Elf_Internal_Rela * rels;
1066
1067   if (is_rela == UNKNOWN)
1068     is_rela = guess_is_rela (elf_header.e_machine);
1069
1070   if (is_rela)
1071     {
1072       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1073         return;
1074     }
1075   else
1076     {
1077       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1078         return;
1079     }
1080
1081   if (is_32bit_elf)
1082     {
1083       if (is_rela)
1084         {
1085           if (do_wide)
1086             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1087           else
1088             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1089         }
1090       else
1091         {
1092           if (do_wide)
1093             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1094           else
1095             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1096         }
1097     }
1098   else
1099     {
1100       if (is_rela)
1101         {
1102           if (do_wide)
1103             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1104           else
1105             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1106         }
1107       else
1108         {
1109           if (do_wide)
1110             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1111           else
1112             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1113         }
1114     }
1115
1116   for (i = 0; i < rel_size; i++)
1117     {
1118       const char * rtype;
1119       bfd_vma offset;
1120       bfd_vma inf;
1121       bfd_vma symtab_index;
1122       bfd_vma type;
1123
1124       offset = rels[i].r_offset;
1125       inf    = rels[i].r_info;
1126
1127       type = get_reloc_type (inf);
1128       symtab_index = get_reloc_symindex  (inf);
1129
1130       if (is_32bit_elf)
1131         {
1132           printf ("%8.8lx  %8.8lx ",
1133                   (unsigned long) offset & 0xffffffff,
1134                   (unsigned long) inf & 0xffffffff);
1135         }
1136       else
1137         {
1138 #if BFD_HOST_64BIT_LONG
1139           printf (do_wide
1140                   ? "%16.16lx  %16.16lx "
1141                   : "%12.12lx  %12.12lx ",
1142                   offset, inf);
1143 #elif BFD_HOST_64BIT_LONG_LONG
1144 #ifndef __MSVCRT__
1145           printf (do_wide
1146                   ? "%16.16llx  %16.16llx "
1147                   : "%12.12llx  %12.12llx ",
1148                   offset, inf);
1149 #else
1150           printf (do_wide
1151                   ? "%16.16I64x  %16.16I64x "
1152                   : "%12.12I64x  %12.12I64x ",
1153                   offset, inf);
1154 #endif
1155 #else
1156           printf (do_wide
1157                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1158                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1159                   _bfd_int64_high (offset),
1160                   _bfd_int64_low (offset),
1161                   _bfd_int64_high (inf),
1162                   _bfd_int64_low (inf));
1163 #endif
1164         }
1165
1166       switch (elf_header.e_machine)
1167         {
1168         default:
1169           rtype = NULL;
1170           break;
1171
1172         case EM_AARCH64:
1173           rtype = elf_aarch64_reloc_type (type);
1174           break;
1175
1176         case EM_M32R:
1177         case EM_CYGNUS_M32R:
1178           rtype = elf_m32r_reloc_type (type);
1179           break;
1180
1181         case EM_386:
1182         case EM_IAMCU:
1183           rtype = elf_i386_reloc_type (type);
1184           break;
1185
1186         case EM_68HC11:
1187         case EM_68HC12:
1188           rtype = elf_m68hc11_reloc_type (type);
1189           break;
1190
1191         case EM_68K:
1192           rtype = elf_m68k_reloc_type (type);
1193           break;
1194
1195         case EM_960:
1196           rtype = elf_i960_reloc_type (type);
1197           break;
1198
1199         case EM_AVR:
1200         case EM_AVR_OLD:
1201           rtype = elf_avr_reloc_type (type);
1202           break;
1203
1204         case EM_OLD_SPARCV9:
1205         case EM_SPARC32PLUS:
1206         case EM_SPARCV9:
1207         case EM_SPARC:
1208           rtype = elf_sparc_reloc_type (type);
1209           break;
1210
1211         case EM_SPU:
1212           rtype = elf_spu_reloc_type (type);
1213           break;
1214
1215         case EM_V800:
1216           rtype = v800_reloc_type (type);
1217           break;
1218         case EM_V850:
1219         case EM_CYGNUS_V850:
1220           rtype = v850_reloc_type (type);
1221           break;
1222
1223         case EM_D10V:
1224         case EM_CYGNUS_D10V:
1225           rtype = elf_d10v_reloc_type (type);
1226           break;
1227
1228         case EM_D30V:
1229         case EM_CYGNUS_D30V:
1230           rtype = elf_d30v_reloc_type (type);
1231           break;
1232
1233         case EM_DLX:
1234           rtype = elf_dlx_reloc_type (type);
1235           break;
1236
1237         case EM_SH:
1238           rtype = elf_sh_reloc_type (type);
1239           break;
1240
1241         case EM_MN10300:
1242         case EM_CYGNUS_MN10300:
1243           rtype = elf_mn10300_reloc_type (type);
1244           break;
1245
1246         case EM_MN10200:
1247         case EM_CYGNUS_MN10200:
1248           rtype = elf_mn10200_reloc_type (type);
1249           break;
1250
1251         case EM_FR30:
1252         case EM_CYGNUS_FR30:
1253           rtype = elf_fr30_reloc_type (type);
1254           break;
1255
1256         case EM_CYGNUS_FRV:
1257           rtype = elf_frv_reloc_type (type);
1258           break;
1259
1260         case EM_FT32:
1261           rtype = elf_ft32_reloc_type (type);
1262           break;
1263
1264         case EM_MCORE:
1265           rtype = elf_mcore_reloc_type (type);
1266           break;
1267
1268         case EM_MMIX:
1269           rtype = elf_mmix_reloc_type (type);
1270           break;
1271
1272         case EM_MOXIE:
1273           rtype = elf_moxie_reloc_type (type);
1274           break;
1275
1276         case EM_MSP430:
1277           if (uses_msp430x_relocs ())
1278             {
1279               rtype = elf_msp430x_reloc_type (type);
1280               break;
1281             }
1282         case EM_MSP430_OLD:
1283           rtype = elf_msp430_reloc_type (type);
1284           break;
1285
1286         case EM_NDS32:
1287           rtype = elf_nds32_reloc_type (type);
1288           break;
1289
1290         case EM_PPC:
1291           rtype = elf_ppc_reloc_type (type);
1292           break;
1293
1294         case EM_PPC64:
1295           rtype = elf_ppc64_reloc_type (type);
1296           break;
1297
1298         case EM_MIPS:
1299         case EM_MIPS_RS3_LE:
1300           rtype = elf_mips_reloc_type (type);
1301           break;
1302
1303         case EM_ALPHA:
1304           rtype = elf_alpha_reloc_type (type);
1305           break;
1306
1307         case EM_ARM:
1308           rtype = elf_arm_reloc_type (type);
1309           break;
1310
1311         case EM_ARC:
1312           rtype = elf_arc_reloc_type (type);
1313           break;
1314
1315         case EM_PARISC:
1316           rtype = elf_hppa_reloc_type (type);
1317           break;
1318
1319         case EM_H8_300:
1320         case EM_H8_300H:
1321         case EM_H8S:
1322           rtype = elf_h8_reloc_type (type);
1323           break;
1324
1325         case EM_OR1K:
1326           rtype = elf_or1k_reloc_type (type);
1327           break;
1328
1329         case EM_PJ:
1330         case EM_PJ_OLD:
1331           rtype = elf_pj_reloc_type (type);
1332           break;
1333         case EM_IA_64:
1334           rtype = elf_ia64_reloc_type (type);
1335           break;
1336
1337         case EM_CRIS:
1338           rtype = elf_cris_reloc_type (type);
1339           break;
1340
1341         case EM_860:
1342           rtype = elf_i860_reloc_type (type);
1343           break;
1344
1345         case EM_X86_64:
1346         case EM_L1OM:
1347         case EM_K1OM:
1348           rtype = elf_x86_64_reloc_type (type);
1349           break;
1350
1351         case EM_S370:
1352           rtype = i370_reloc_type (type);
1353           break;
1354
1355         case EM_S390_OLD:
1356         case EM_S390:
1357           rtype = elf_s390_reloc_type (type);
1358           break;
1359
1360         case EM_SCORE:
1361           rtype = elf_score_reloc_type (type);
1362           break;
1363
1364         case EM_XSTORMY16:
1365           rtype = elf_xstormy16_reloc_type (type);
1366           break;
1367
1368         case EM_CRX:
1369           rtype = elf_crx_reloc_type (type);
1370           break;
1371
1372         case EM_VAX:
1373           rtype = elf_vax_reloc_type (type);
1374           break;
1375
1376         case EM_VISIUM:
1377           rtype = elf_visium_reloc_type (type);
1378           break;
1379
1380         case EM_ADAPTEVA_EPIPHANY:
1381           rtype = elf_epiphany_reloc_type (type);
1382           break;
1383
1384         case EM_IP2K:
1385         case EM_IP2K_OLD:
1386           rtype = elf_ip2k_reloc_type (type);
1387           break;
1388
1389         case EM_IQ2000:
1390           rtype = elf_iq2000_reloc_type (type);
1391           break;
1392
1393         case EM_XTENSA_OLD:
1394         case EM_XTENSA:
1395           rtype = elf_xtensa_reloc_type (type);
1396           break;
1397
1398         case EM_LATTICEMICO32:
1399           rtype = elf_lm32_reloc_type (type);
1400           break;
1401
1402         case EM_M32C_OLD:
1403         case EM_M32C:
1404           rtype = elf_m32c_reloc_type (type);
1405           break;
1406
1407         case EM_MT:
1408           rtype = elf_mt_reloc_type (type);
1409           break;
1410
1411         case EM_BLACKFIN:
1412           rtype = elf_bfin_reloc_type (type);
1413           break;
1414
1415         case EM_CYGNUS_MEP:
1416           rtype = elf_mep_reloc_type (type);
1417           break;
1418
1419         case EM_CR16:
1420           rtype = elf_cr16_reloc_type (type);
1421           break;
1422
1423         case EM_MICROBLAZE:
1424         case EM_MICROBLAZE_OLD:
1425           rtype = elf_microblaze_reloc_type (type);
1426           break;
1427
1428         case EM_RL78:
1429           rtype = elf_rl78_reloc_type (type);
1430           break;
1431
1432         case EM_RX:
1433           rtype = elf_rx_reloc_type (type);
1434           break;
1435
1436         case EM_METAG:
1437           rtype = elf_metag_reloc_type (type);
1438           break;
1439
1440         case EM_XC16X:
1441         case EM_C166:
1442           rtype = elf_xc16x_reloc_type (type);
1443           break;
1444
1445         case EM_TI_C6000:
1446           rtype = elf_tic6x_reloc_type (type);
1447           break;
1448
1449         case EM_TILEGX:
1450           rtype = elf_tilegx_reloc_type (type);
1451           break;
1452
1453         case EM_TILEPRO:
1454           rtype = elf_tilepro_reloc_type (type);
1455           break;
1456
1457         case EM_XGATE:
1458           rtype = elf_xgate_reloc_type (type);
1459           break;
1460
1461         case EM_ALTERA_NIOS2:
1462           rtype = elf_nios2_reloc_type (type);
1463           break;
1464         }
1465
1466       if (rtype == NULL)
1467         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1468       else
1469         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1470
1471       if (elf_header.e_machine == EM_ALPHA
1472           && rtype != NULL
1473           && streq (rtype, "R_ALPHA_LITUSE")
1474           && is_rela)
1475         {
1476           switch (rels[i].r_addend)
1477             {
1478             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1479             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1480             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1481             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1482             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1483             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1484             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1485             default: rtype = NULL;
1486             }
1487           if (rtype)
1488             printf (" (%s)", rtype);
1489           else
1490             {
1491               putchar (' ');
1492               printf (_("<unknown addend: %lx>"),
1493                       (unsigned long) rels[i].r_addend);
1494             }
1495         }
1496       else if (symtab_index)
1497         {
1498           if (symtab == NULL || symtab_index >= nsyms)
1499             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1500           else
1501             {
1502               Elf_Internal_Sym * psym;
1503               const char * version_string;
1504               enum versioned_symbol_info sym_info;
1505               unsigned short vna_other;
1506
1507               psym = symtab + symtab_index;
1508
1509               version_string
1510                 = get_symbol_version_string (file, is_dynsym,
1511                                              strtab, strtablen,
1512                                              symtab_index,
1513                                              psym,
1514                                              &sym_info,
1515                                              &vna_other);
1516
1517               printf (" ");
1518
1519               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1520                 {
1521                   const char * name;
1522                   unsigned int len;
1523                   unsigned int width = is_32bit_elf ? 8 : 14;
1524
1525                   /* Relocations against GNU_IFUNC symbols do not use the value
1526                      of the symbol as the address to relocate against.  Instead
1527                      they invoke the function named by the symbol and use its
1528                      result as the address for relocation.
1529
1530                      To indicate this to the user, do not display the value of
1531                      the symbol in the "Symbols's Value" field.  Instead show
1532                      its name followed by () as a hint that the symbol is
1533                      invoked.  */
1534
1535                   if (strtab == NULL
1536                       || psym->st_name == 0
1537                       || psym->st_name >= strtablen)
1538                     name = "??";
1539                   else
1540                     name = strtab + psym->st_name;
1541
1542                   len = print_symbol (width, name);
1543                   if (version_string)
1544                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1545                             version_string);
1546                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1547                 }
1548               else
1549                 {
1550                   print_vma (psym->st_value, LONG_HEX);
1551
1552                   printf (is_32bit_elf ? "   " : " ");
1553                 }
1554
1555               if (psym->st_name == 0)
1556                 {
1557                   const char * sec_name = "<null>";
1558                   char name_buf[40];
1559
1560                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1561                     {
1562                       if (psym->st_shndx < elf_header.e_shnum)
1563                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1564                       else if (psym->st_shndx == SHN_ABS)
1565                         sec_name = "ABS";
1566                       else if (psym->st_shndx == SHN_COMMON)
1567                         sec_name = "COMMON";
1568                       else if ((elf_header.e_machine == EM_MIPS
1569                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1570                                || (elf_header.e_machine == EM_TI_C6000
1571                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1572                         sec_name = "SCOMMON";
1573                       else if (elf_header.e_machine == EM_MIPS
1574                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1575                         sec_name = "SUNDEF";
1576                       else if ((elf_header.e_machine == EM_X86_64
1577                                 || elf_header.e_machine == EM_L1OM
1578                                 || elf_header.e_machine == EM_K1OM)
1579                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1580                         sec_name = "LARGE_COMMON";
1581                       else if (elf_header.e_machine == EM_IA_64
1582                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1583                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1584                         sec_name = "ANSI_COM";
1585                       else if (is_ia64_vms ()
1586                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1587                         sec_name = "VMS_SYMVEC";
1588                       else
1589                         {
1590                           sprintf (name_buf, "<section 0x%x>",
1591                                    (unsigned int) psym->st_shndx);
1592                           sec_name = name_buf;
1593                         }
1594                     }
1595                   print_symbol (22, sec_name);
1596                 }
1597               else if (strtab == NULL)
1598                 printf (_("<string table index: %3ld>"), psym->st_name);
1599               else if (psym->st_name >= strtablen)
1600                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1601               else
1602                 {
1603                   print_symbol (22, strtab + psym->st_name);
1604                   if (version_string)
1605                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1606                             version_string);
1607                 }
1608
1609               if (is_rela)
1610                 {
1611                   bfd_signed_vma off = rels[i].r_addend;
1612
1613                   /* PR 17531: file: 2e63226f.  */
1614                   if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1615                     printf (" + %" BFD_VMA_FMT "x", off);
1616                   else if (off < 0)
1617                     printf (" - %" BFD_VMA_FMT "x", - off);
1618                   else
1619                     printf (" + %" BFD_VMA_FMT "x", off);
1620                 }
1621             }
1622         }
1623       else if (is_rela)
1624         {
1625           bfd_signed_vma off = rels[i].r_addend;
1626
1627           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1628           /* PR 17531: file: 2e63226f.  */
1629           if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1630             printf ("%" BFD_VMA_FMT "x", off);
1631           else if (off < 0)
1632             printf ("-%" BFD_VMA_FMT "x", - off);
1633           else
1634             printf ("%" BFD_VMA_FMT "x", off);
1635         }
1636
1637       if (elf_header.e_machine == EM_SPARCV9
1638           && rtype != NULL
1639           && streq (rtype, "R_SPARC_OLO10"))
1640         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1641
1642       putchar ('\n');
1643
1644 #ifdef BFD64
1645       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1646         {
1647           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1648           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1649           const char * rtype2 = elf_mips_reloc_type (type2);
1650           const char * rtype3 = elf_mips_reloc_type (type3);
1651
1652           printf ("                    Type2: ");
1653
1654           if (rtype2 == NULL)
1655             printf (_("unrecognized: %-7lx"),
1656                     (unsigned long) type2 & 0xffffffff);
1657           else
1658             printf ("%-17.17s", rtype2);
1659
1660           printf ("\n                    Type3: ");
1661
1662           if (rtype3 == NULL)
1663             printf (_("unrecognized: %-7lx"),
1664                     (unsigned long) type3 & 0xffffffff);
1665           else
1666             printf ("%-17.17s", rtype3);
1667
1668           putchar ('\n');
1669         }
1670 #endif /* BFD64 */
1671     }
1672
1673   free (rels);
1674 }
1675
1676 static const char *
1677 get_mips_dynamic_type (unsigned long type)
1678 {
1679   switch (type)
1680     {
1681     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1682     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1683     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1684     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1685     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1686     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1687     case DT_MIPS_MSYM: return "MIPS_MSYM";
1688     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1689     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1690     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1691     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1692     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1693     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1694     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1695     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1696     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1697     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1698     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1699     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1700     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1701     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1702     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1703     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1704     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1705     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1706     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1707     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1708     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1709     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1710     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1711     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1712     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1713     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1714     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1715     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1716     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1717     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1718     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1719     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1720     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1721     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1722     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1723     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1724     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1725     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1726     default:
1727       return NULL;
1728     }
1729 }
1730
1731 static const char *
1732 get_sparc64_dynamic_type (unsigned long type)
1733 {
1734   switch (type)
1735     {
1736     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1737     default:
1738       return NULL;
1739     }
1740 }
1741
1742 static const char *
1743 get_ppc_dynamic_type (unsigned long type)
1744 {
1745   switch (type)
1746     {
1747     case DT_PPC_GOT:    return "PPC_GOT";
1748     case DT_PPC_OPT:    return "PPC_OPT";
1749     default:
1750       return NULL;
1751     }
1752 }
1753
1754 static const char *
1755 get_ppc64_dynamic_type (unsigned long type)
1756 {
1757   switch (type)
1758     {
1759     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1760     case DT_PPC64_OPD:    return "PPC64_OPD";
1761     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1762     case DT_PPC64_OPT:    return "PPC64_OPT";
1763     default:
1764       return NULL;
1765     }
1766 }
1767
1768 static const char *
1769 get_parisc_dynamic_type (unsigned long type)
1770 {
1771   switch (type)
1772     {
1773     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1774     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1775     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1776     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1777     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1778     case DT_HP_PREINIT:         return "HP_PREINIT";
1779     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1780     case DT_HP_NEEDED:          return "HP_NEEDED";
1781     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1782     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1783     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1784     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1785     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1786     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1787     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1788     case DT_HP_FILTERED:        return "HP_FILTERED";
1789     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1790     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1791     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1792     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1793     case DT_PLT:                return "PLT";
1794     case DT_PLT_SIZE:           return "PLT_SIZE";
1795     case DT_DLT:                return "DLT";
1796     case DT_DLT_SIZE:           return "DLT_SIZE";
1797     default:
1798       return NULL;
1799     }
1800 }
1801
1802 static const char *
1803 get_ia64_dynamic_type (unsigned long type)
1804 {
1805   switch (type)
1806     {
1807     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1808     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1809     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1810     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1811     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1812     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1813     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1814     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1815     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1816     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1817     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1818     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1819     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1820     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1821     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1822     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1823     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1824     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1825     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1826     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1827     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1828     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1829     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1830     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1831     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1832     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1833     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1834     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1835     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1836     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1837     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1838     default:
1839       return NULL;
1840     }
1841 }
1842
1843 static const char *
1844 get_alpha_dynamic_type (unsigned long type)
1845 {
1846   switch (type)
1847     {
1848     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1849     default:
1850       return NULL;
1851     }
1852 }
1853
1854 static const char *
1855 get_score_dynamic_type (unsigned long type)
1856 {
1857   switch (type)
1858     {
1859     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1860     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1861     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1862     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1863     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1864     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1865     default:
1866       return NULL;
1867     }
1868 }
1869
1870 static const char *
1871 get_tic6x_dynamic_type (unsigned long type)
1872 {
1873   switch (type)
1874     {
1875     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1876     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1877     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1878     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1879     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1880     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1881     default:
1882       return NULL;
1883     }
1884 }
1885
1886 static const char *
1887 get_nios2_dynamic_type (unsigned long type)
1888 {
1889   switch (type)
1890     {
1891     case DT_NIOS2_GP: return "NIOS2_GP";
1892     default:
1893       return NULL;
1894     }
1895 }
1896
1897 static const char *
1898 get_dynamic_type (unsigned long type)
1899 {
1900   static char buff[64];
1901
1902   switch (type)
1903     {
1904     case DT_NULL:       return "NULL";
1905     case DT_NEEDED:     return "NEEDED";
1906     case DT_PLTRELSZ:   return "PLTRELSZ";
1907     case DT_PLTGOT:     return "PLTGOT";
1908     case DT_HASH:       return "HASH";
1909     case DT_STRTAB:     return "STRTAB";
1910     case DT_SYMTAB:     return "SYMTAB";
1911     case DT_RELA:       return "RELA";
1912     case DT_RELASZ:     return "RELASZ";
1913     case DT_RELAENT:    return "RELAENT";
1914     case DT_STRSZ:      return "STRSZ";
1915     case DT_SYMENT:     return "SYMENT";
1916     case DT_INIT:       return "INIT";
1917     case DT_FINI:       return "FINI";
1918     case DT_SONAME:     return "SONAME";
1919     case DT_RPATH:      return "RPATH";
1920     case DT_SYMBOLIC:   return "SYMBOLIC";
1921     case DT_REL:        return "REL";
1922     case DT_RELSZ:      return "RELSZ";
1923     case DT_RELENT:     return "RELENT";
1924     case DT_PLTREL:     return "PLTREL";
1925     case DT_DEBUG:      return "DEBUG";
1926     case DT_TEXTREL:    return "TEXTREL";
1927     case DT_JMPREL:     return "JMPREL";
1928     case DT_BIND_NOW:   return "BIND_NOW";
1929     case DT_INIT_ARRAY: return "INIT_ARRAY";
1930     case DT_FINI_ARRAY: return "FINI_ARRAY";
1931     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1932     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1933     case DT_RUNPATH:    return "RUNPATH";
1934     case DT_FLAGS:      return "FLAGS";
1935
1936     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1937     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1938
1939     case DT_CHECKSUM:   return "CHECKSUM";
1940     case DT_PLTPADSZ:   return "PLTPADSZ";
1941     case DT_MOVEENT:    return "MOVEENT";
1942     case DT_MOVESZ:     return "MOVESZ";
1943     case DT_FEATURE:    return "FEATURE";
1944     case DT_POSFLAG_1:  return "POSFLAG_1";
1945     case DT_SYMINSZ:    return "SYMINSZ";
1946     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1947
1948     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1949     case DT_CONFIG:     return "CONFIG";
1950     case DT_DEPAUDIT:   return "DEPAUDIT";
1951     case DT_AUDIT:      return "AUDIT";
1952     case DT_PLTPAD:     return "PLTPAD";
1953     case DT_MOVETAB:    return "MOVETAB";
1954     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1955
1956     case DT_VERSYM:     return "VERSYM";
1957
1958     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1959     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1960     case DT_RELACOUNT:  return "RELACOUNT";
1961     case DT_RELCOUNT:   return "RELCOUNT";
1962     case DT_FLAGS_1:    return "FLAGS_1";
1963     case DT_VERDEF:     return "VERDEF";
1964     case DT_VERDEFNUM:  return "VERDEFNUM";
1965     case DT_VERNEED:    return "VERNEED";
1966     case DT_VERNEEDNUM: return "VERNEEDNUM";
1967
1968     case DT_AUXILIARY:  return "AUXILIARY";
1969     case DT_USED:       return "USED";
1970     case DT_FILTER:     return "FILTER";
1971
1972     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1973     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1974     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1975     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1976     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1977     case DT_GNU_HASH:   return "GNU_HASH";
1978
1979     default:
1980       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1981         {
1982           const char * result;
1983
1984           switch (elf_header.e_machine)
1985             {
1986             case EM_MIPS:
1987             case EM_MIPS_RS3_LE:
1988               result = get_mips_dynamic_type (type);
1989               break;
1990             case EM_SPARCV9:
1991               result = get_sparc64_dynamic_type (type);
1992               break;
1993             case EM_PPC:
1994               result = get_ppc_dynamic_type (type);
1995               break;
1996             case EM_PPC64:
1997               result = get_ppc64_dynamic_type (type);
1998               break;
1999             case EM_IA_64:
2000               result = get_ia64_dynamic_type (type);
2001               break;
2002             case EM_ALPHA:
2003               result = get_alpha_dynamic_type (type);
2004               break;
2005             case EM_SCORE:
2006               result = get_score_dynamic_type (type);
2007               break;
2008             case EM_TI_C6000:
2009               result = get_tic6x_dynamic_type (type);
2010               break;
2011             case EM_ALTERA_NIOS2:
2012               result = get_nios2_dynamic_type (type);
2013               break;
2014             default:
2015               result = NULL;
2016               break;
2017             }
2018
2019           if (result != NULL)
2020             return result;
2021
2022           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2023         }
2024       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2025                || (elf_header.e_machine == EM_PARISC
2026                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2027         {
2028           const char * result;
2029
2030           switch (elf_header.e_machine)
2031             {
2032             case EM_PARISC:
2033               result = get_parisc_dynamic_type (type);
2034               break;
2035             case EM_IA_64:
2036               result = get_ia64_dynamic_type (type);
2037               break;
2038             default:
2039               result = NULL;
2040               break;
2041             }
2042
2043           if (result != NULL)
2044             return result;
2045
2046           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2047                     type);
2048         }
2049       else
2050         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2051
2052       return buff;
2053     }
2054 }
2055
2056 static char *
2057 get_file_type (unsigned e_type)
2058 {
2059   static char buff[32];
2060
2061   switch (e_type)
2062     {
2063     case ET_NONE:       return _("NONE (None)");
2064     case ET_REL:        return _("REL (Relocatable file)");
2065     case ET_EXEC:       return _("EXEC (Executable file)");
2066     case ET_DYN:        return _("DYN (Shared object file)");
2067     case ET_CORE:       return _("CORE (Core file)");
2068
2069     default:
2070       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2071         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2072       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2073         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2074       else
2075         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2076       return buff;
2077     }
2078 }
2079
2080 static char *
2081 get_machine_name (unsigned e_machine)
2082 {
2083   static char buff[64]; /* XXX */
2084
2085   switch (e_machine)
2086     {
2087     case EM_NONE:               return _("None");
2088     case EM_AARCH64:            return "AArch64";
2089     case EM_M32:                return "WE32100";
2090     case EM_SPARC:              return "Sparc";
2091     case EM_SPU:                return "SPU";
2092     case EM_386:                return "Intel 80386";
2093     case EM_68K:                return "MC68000";
2094     case EM_88K:                return "MC88000";
2095     case EM_IAMCU:              return "Intel MCU";
2096     case EM_860:                return "Intel 80860";
2097     case EM_MIPS:               return "MIPS R3000";
2098     case EM_S370:               return "IBM System/370";
2099     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2100     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2101     case EM_PARISC:             return "HPPA";
2102     case EM_PPC_OLD:            return "Power PC (old)";
2103     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2104     case EM_960:                return "Intel 90860";
2105     case EM_PPC:                return "PowerPC";
2106     case EM_PPC64:              return "PowerPC64";
2107     case EM_FR20:               return "Fujitsu FR20";
2108     case EM_FT32:               return "FTDI FT32";
2109     case EM_RH32:               return "TRW RH32";
2110     case EM_MCORE:              return "MCORE";
2111     case EM_ARM:                return "ARM";
2112     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2113     case EM_SH:                 return "Renesas / SuperH SH";
2114     case EM_SPARCV9:            return "Sparc v9";
2115     case EM_TRICORE:            return "Siemens Tricore";
2116     case EM_ARC:                return "ARC";
2117     case EM_H8_300:             return "Renesas H8/300";
2118     case EM_H8_300H:            return "Renesas H8/300H";
2119     case EM_H8S:                return "Renesas H8S";
2120     case EM_H8_500:             return "Renesas H8/500";
2121     case EM_IA_64:              return "Intel IA-64";
2122     case EM_MIPS_X:             return "Stanford MIPS-X";
2123     case EM_COLDFIRE:           return "Motorola Coldfire";
2124     case EM_ALPHA:              return "Alpha";
2125     case EM_CYGNUS_D10V:
2126     case EM_D10V:               return "d10v";
2127     case EM_CYGNUS_D30V:
2128     case EM_D30V:               return "d30v";
2129     case EM_CYGNUS_M32R:
2130     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2131     case EM_CYGNUS_V850:
2132     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2133     case EM_V850:               return "Renesas V850";
2134     case EM_CYGNUS_MN10300:
2135     case EM_MN10300:            return "mn10300";
2136     case EM_CYGNUS_MN10200:
2137     case EM_MN10200:            return "mn10200";
2138     case EM_MOXIE:              return "Moxie";
2139     case EM_CYGNUS_FR30:
2140     case EM_FR30:               return "Fujitsu FR30";
2141     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2142     case EM_PJ_OLD:
2143     case EM_PJ:                 return "picoJava";
2144     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2145     case EM_PCP:                return "Siemens PCP";
2146     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2147     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2148     case EM_STARCORE:           return "Motorola Star*Core processor";
2149     case EM_ME16:               return "Toyota ME16 processor";
2150     case EM_ST100:              return "STMicroelectronics ST100 processor";
2151     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2152     case EM_PDSP:               return "Sony DSP processor";
2153     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2154     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2155     case EM_FX66:               return "Siemens FX66 microcontroller";
2156     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2157     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2158     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2159     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2160     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2161     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2162     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2163     case EM_SVX:                return "Silicon Graphics SVx";
2164     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2165     case EM_VAX:                return "Digital VAX";
2166     case EM_VISIUM:             return "CDS VISIUMcore processor";
2167     case EM_AVR_OLD:
2168     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2169     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2170     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2171     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2172     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2173     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2174     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2175     case EM_PRISM:              return "Vitesse Prism";
2176     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2177     case EM_L1OM:               return "Intel L1OM";
2178     case EM_K1OM:               return "Intel K1OM";
2179     case EM_S390_OLD:
2180     case EM_S390:               return "IBM S/390";
2181     case EM_SCORE:              return "SUNPLUS S+Core";
2182     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2183     case EM_OR1K:               return "OpenRISC 1000";
2184     case EM_ARC_A5:             return "ARC International ARCompact processor";
2185     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2186     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2187     case EM_DLX:                return "OpenDLX";
2188     case EM_IP2K_OLD:
2189     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2190     case EM_IQ2000:             return "Vitesse IQ2000";
2191     case EM_XTENSA_OLD:
2192     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2193     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2194     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2195     case EM_NS32K:              return "National Semiconductor 32000 series";
2196     case EM_TPC:                return "Tenor Network TPC processor";
2197     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2198     case EM_MAX:                return "MAX Processor";
2199     case EM_CR:                 return "National Semiconductor CompactRISC";
2200     case EM_F2MC16:             return "Fujitsu F2MC16";
2201     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2202     case EM_LATTICEMICO32:      return "Lattice Mico32";
2203     case EM_M32C_OLD:
2204     case EM_M32C:               return "Renesas M32c";
2205     case EM_MT:                 return "Morpho Techologies MT processor";
2206     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2207     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2208     case EM_SEP:                return "Sharp embedded microprocessor";
2209     case EM_ARCA:               return "Arca RISC microprocessor";
2210     case EM_UNICORE:            return "Unicore";
2211     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2212     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2213     case EM_NIOS32:             return "Altera Nios";
2214     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2215     case EM_C166:
2216     case EM_XC16X:              return "Infineon Technologies xc16x";
2217     case EM_M16C:               return "Renesas M16C series microprocessors";
2218     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2219     case EM_CE:                 return "Freescale Communication Engine RISC core";
2220     case EM_TSK3000:            return "Altium TSK3000 core";
2221     case EM_RS08:               return "Freescale RS08 embedded processor";
2222     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2223     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2224     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2225     case EM_SE_C17:             return "Seiko Epson C17 family";
2226     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2227     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2228     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2229     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2230     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2231     case EM_R32C:               return "Renesas R32C series microprocessors";
2232     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2233     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2234     case EM_8051:               return "Intel 8051 and variants";
2235     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2236     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2237     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2238     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2239     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2240     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2241     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2242     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2243     case EM_CR16:
2244     case EM_MICROBLAZE:
2245     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2246     case EM_RL78:               return "Renesas RL78";
2247     case EM_RX:                 return "Renesas RX";
2248     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2249     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2250     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2251     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2252     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2253     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2254     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2255     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2256     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2257     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2258     case EM_CUDA:               return "NVIDIA CUDA architecture";
2259     case EM_XGATE:              return "Motorola XGATE embedded processor";
2260     default:
2261       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2262       return buff;
2263     }
2264 }
2265
2266 static void
2267 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2268 {
2269   unsigned eabi;
2270   int unknown = 0;
2271
2272   eabi = EF_ARM_EABI_VERSION (e_flags);
2273   e_flags &= ~ EF_ARM_EABIMASK;
2274
2275   /* Handle "generic" ARM flags.  */
2276   if (e_flags & EF_ARM_RELEXEC)
2277     {
2278       strcat (buf, ", relocatable executable");
2279       e_flags &= ~ EF_ARM_RELEXEC;
2280     }
2281
2282   /* Now handle EABI specific flags.  */
2283   switch (eabi)
2284     {
2285     default:
2286       strcat (buf, ", <unrecognized EABI>");
2287       if (e_flags)
2288         unknown = 1;
2289       break;
2290
2291     case EF_ARM_EABI_VER1:
2292       strcat (buf, ", Version1 EABI");
2293       while (e_flags)
2294         {
2295           unsigned flag;
2296
2297           /* Process flags one bit at a time.  */
2298           flag = e_flags & - e_flags;
2299           e_flags &= ~ flag;
2300
2301           switch (flag)
2302             {
2303             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2304               strcat (buf, ", sorted symbol tables");
2305               break;
2306
2307             default:
2308               unknown = 1;
2309               break;
2310             }
2311         }
2312       break;
2313
2314     case EF_ARM_EABI_VER2:
2315       strcat (buf, ", Version2 EABI");
2316       while (e_flags)
2317         {
2318           unsigned flag;
2319
2320           /* Process flags one bit at a time.  */
2321           flag = e_flags & - e_flags;
2322           e_flags &= ~ flag;
2323
2324           switch (flag)
2325             {
2326             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2327               strcat (buf, ", sorted symbol tables");
2328               break;
2329
2330             case EF_ARM_DYNSYMSUSESEGIDX:
2331               strcat (buf, ", dynamic symbols use segment index");
2332               break;
2333
2334             case EF_ARM_MAPSYMSFIRST:
2335               strcat (buf, ", mapping symbols precede others");
2336               break;
2337
2338             default:
2339               unknown = 1;
2340               break;
2341             }
2342         }
2343       break;
2344
2345     case EF_ARM_EABI_VER3:
2346       strcat (buf, ", Version3 EABI");
2347       break;
2348
2349     case EF_ARM_EABI_VER4:
2350       strcat (buf, ", Version4 EABI");
2351       while (e_flags)
2352         {
2353           unsigned flag;
2354
2355           /* Process flags one bit at a time.  */
2356           flag = e_flags & - e_flags;
2357           e_flags &= ~ flag;
2358
2359           switch (flag)
2360             {
2361             case EF_ARM_BE8:
2362               strcat (buf, ", BE8");
2363               break;
2364
2365             case EF_ARM_LE8:
2366               strcat (buf, ", LE8");
2367               break;
2368
2369             default:
2370               unknown = 1;
2371               break;
2372             }
2373       break;
2374         }
2375       break;
2376
2377     case EF_ARM_EABI_VER5:
2378       strcat (buf, ", Version5 EABI");
2379       while (e_flags)
2380         {
2381           unsigned flag;
2382
2383           /* Process flags one bit at a time.  */
2384           flag = e_flags & - e_flags;
2385           e_flags &= ~ flag;
2386
2387           switch (flag)
2388             {
2389             case EF_ARM_BE8:
2390               strcat (buf, ", BE8");
2391               break;
2392
2393             case EF_ARM_LE8:
2394               strcat (buf, ", LE8");
2395               break;
2396
2397             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2398               strcat (buf, ", soft-float ABI");
2399               break;
2400
2401             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2402               strcat (buf, ", hard-float ABI");
2403               break;
2404
2405             default:
2406               unknown = 1;
2407               break;
2408             }
2409         }
2410       break;
2411
2412     case EF_ARM_EABI_UNKNOWN:
2413       strcat (buf, ", GNU EABI");
2414       while (e_flags)
2415         {
2416           unsigned flag;
2417
2418           /* Process flags one bit at a time.  */
2419           flag = e_flags & - e_flags;
2420           e_flags &= ~ flag;
2421
2422           switch (flag)
2423             {
2424             case EF_ARM_INTERWORK:
2425               strcat (buf, ", interworking enabled");
2426               break;
2427
2428             case EF_ARM_APCS_26:
2429               strcat (buf, ", uses APCS/26");
2430               break;
2431
2432             case EF_ARM_APCS_FLOAT:
2433               strcat (buf, ", uses APCS/float");
2434               break;
2435
2436             case EF_ARM_PIC:
2437               strcat (buf, ", position independent");
2438               break;
2439
2440             case EF_ARM_ALIGN8:
2441               strcat (buf, ", 8 bit structure alignment");
2442               break;
2443
2444             case EF_ARM_NEW_ABI:
2445               strcat (buf, ", uses new ABI");
2446               break;
2447
2448             case EF_ARM_OLD_ABI:
2449               strcat (buf, ", uses old ABI");
2450               break;
2451
2452             case EF_ARM_SOFT_FLOAT:
2453               strcat (buf, ", software FP");
2454               break;
2455
2456             case EF_ARM_VFP_FLOAT:
2457               strcat (buf, ", VFP");
2458               break;
2459
2460             case EF_ARM_MAVERICK_FLOAT:
2461               strcat (buf, ", Maverick FP");
2462               break;
2463
2464             default:
2465               unknown = 1;
2466               break;
2467             }
2468         }
2469     }
2470
2471   if (unknown)
2472     strcat (buf,_(", <unknown>"));
2473 }
2474
2475 static void
2476 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2477 {
2478   --size; /* Leave space for null terminator.  */
2479
2480   switch (e_flags & EF_AVR_MACH)
2481     {
2482     case E_AVR_MACH_AVR1:
2483       strncat (buf, ", avr:1", size);
2484       break;
2485     case E_AVR_MACH_AVR2:
2486       strncat (buf, ", avr:2", size);
2487       break;
2488     case E_AVR_MACH_AVR25:
2489       strncat (buf, ", avr:25", size);
2490       break;
2491     case E_AVR_MACH_AVR3:
2492       strncat (buf, ", avr:3", size);
2493       break;
2494     case E_AVR_MACH_AVR31:
2495       strncat (buf, ", avr:31", size);
2496       break;
2497     case E_AVR_MACH_AVR35:
2498       strncat (buf, ", avr:35", size);
2499       break;
2500     case E_AVR_MACH_AVR4:
2501       strncat (buf, ", avr:4", size);
2502       break;
2503     case E_AVR_MACH_AVR5:
2504       strncat (buf, ", avr:5", size);
2505       break;
2506     case E_AVR_MACH_AVR51:
2507       strncat (buf, ", avr:51", size);
2508       break;
2509     case E_AVR_MACH_AVR6:
2510       strncat (buf, ", avr:6", size);
2511       break;
2512     case E_AVR_MACH_AVRTINY:
2513       strncat (buf, ", avr:100", size);
2514       break;
2515     case E_AVR_MACH_XMEGA1:
2516       strncat (buf, ", avr:101", size);
2517       break;
2518     case E_AVR_MACH_XMEGA2:
2519       strncat (buf, ", avr:102", size);
2520       break;
2521     case E_AVR_MACH_XMEGA3:
2522       strncat (buf, ", avr:103", size);
2523       break;
2524     case E_AVR_MACH_XMEGA4:
2525       strncat (buf, ", avr:104", size);
2526       break;
2527     case E_AVR_MACH_XMEGA5:
2528       strncat (buf, ", avr:105", size);
2529       break;
2530     case E_AVR_MACH_XMEGA6:
2531       strncat (buf, ", avr:106", size);
2532       break;
2533     case E_AVR_MACH_XMEGA7:
2534       strncat (buf, ", avr:107", size);
2535       break;
2536     default:
2537       strncat (buf, ", avr:<unknown>", size);
2538       break;
2539     }
2540
2541   size -= strlen (buf);
2542   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2543     strncat (buf, ", link-relax", size);
2544 }
2545
2546 static void
2547 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2548 {
2549   unsigned abi;
2550   unsigned arch;
2551   unsigned config;
2552   unsigned version;
2553   int has_fpu = 0;
2554   int r = 0;
2555
2556   static const char *ABI_STRINGS[] =
2557   {
2558     "ABI v0", /* use r5 as return register; only used in N1213HC */
2559     "ABI v1", /* use r0 as return register */
2560     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2561     "ABI v2fp", /* for FPU */
2562     "AABI",
2563     "ABI2 FP+"
2564   };
2565   static const char *VER_STRINGS[] =
2566   {
2567     "Andes ELF V1.3 or older",
2568     "Andes ELF V1.3.1",
2569     "Andes ELF V1.4"
2570   };
2571   static const char *ARCH_STRINGS[] =
2572   {
2573     "",
2574     "Andes Star v1.0",
2575     "Andes Star v2.0",
2576     "Andes Star v3.0",
2577     "Andes Star v3.0m"
2578   };
2579
2580   abi = EF_NDS_ABI & e_flags;
2581   arch = EF_NDS_ARCH & e_flags;
2582   config = EF_NDS_INST & e_flags;
2583   version = EF_NDS32_ELF_VERSION & e_flags;
2584
2585   memset (buf, 0, size);
2586
2587   switch (abi)
2588     {
2589     case E_NDS_ABI_V0:
2590     case E_NDS_ABI_V1:
2591     case E_NDS_ABI_V2:
2592     case E_NDS_ABI_V2FP:
2593     case E_NDS_ABI_AABI:
2594     case E_NDS_ABI_V2FP_PLUS:
2595       /* In case there are holes in the array.  */
2596       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2597       break;
2598
2599     default:
2600       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2601       break;
2602     }
2603
2604   switch (version)
2605     {
2606     case E_NDS32_ELF_VER_1_2:
2607     case E_NDS32_ELF_VER_1_3:
2608     case E_NDS32_ELF_VER_1_4:
2609       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2610       break;
2611
2612     default:
2613       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2614       break;
2615     }
2616
2617   if (E_NDS_ABI_V0 == abi)
2618     {
2619       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2620       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2621       if (arch == E_NDS_ARCH_STAR_V1_0)
2622         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2623       return;
2624     }
2625
2626   switch (arch)
2627     {
2628     case E_NDS_ARCH_STAR_V1_0:
2629     case E_NDS_ARCH_STAR_V2_0:
2630     case E_NDS_ARCH_STAR_V3_0:
2631     case E_NDS_ARCH_STAR_V3_M:
2632       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2633       break;
2634
2635     default:
2636       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2637       /* ARCH version determines how the e_flags are interpreted.
2638          If it is unknown, we cannot proceed.  */
2639       return;
2640     }
2641
2642   /* Newer ABI; Now handle architecture specific flags.  */
2643   if (arch == E_NDS_ARCH_STAR_V1_0)
2644     {
2645       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2646         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2647
2648       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2649         r += snprintf (buf + r, size -r, ", MAC");
2650
2651       if (config & E_NDS32_HAS_DIV_INST)
2652         r += snprintf (buf + r, size -r, ", DIV");
2653
2654       if (config & E_NDS32_HAS_16BIT_INST)
2655         r += snprintf (buf + r, size -r, ", 16b");
2656     }
2657   else
2658     {
2659       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2660         {
2661           if (version <= E_NDS32_ELF_VER_1_3)
2662             r += snprintf (buf + r, size -r, ", [B8]");
2663           else
2664             r += snprintf (buf + r, size -r, ", EX9");
2665         }
2666
2667       if (config & E_NDS32_HAS_MAC_DX_INST)
2668         r += snprintf (buf + r, size -r, ", MAC_DX");
2669
2670       if (config & E_NDS32_HAS_DIV_DX_INST)
2671         r += snprintf (buf + r, size -r, ", DIV_DX");
2672
2673       if (config & E_NDS32_HAS_16BIT_INST)
2674         {
2675           if (version <= E_NDS32_ELF_VER_1_3)
2676             r += snprintf (buf + r, size -r, ", 16b");
2677           else
2678             r += snprintf (buf + r, size -r, ", IFC");
2679         }
2680     }
2681
2682   if (config & E_NDS32_HAS_EXT_INST)
2683     r += snprintf (buf + r, size -r, ", PERF1");
2684
2685   if (config & E_NDS32_HAS_EXT2_INST)
2686     r += snprintf (buf + r, size -r, ", PERF2");
2687
2688   if (config & E_NDS32_HAS_FPU_INST)
2689     {
2690       has_fpu = 1;
2691       r += snprintf (buf + r, size -r, ", FPU_SP");
2692     }
2693
2694   if (config & E_NDS32_HAS_FPU_DP_INST)
2695     {
2696       has_fpu = 1;
2697       r += snprintf (buf + r, size -r, ", FPU_DP");
2698     }
2699
2700   if (config & E_NDS32_HAS_FPU_MAC_INST)
2701     {
2702       has_fpu = 1;
2703       r += snprintf (buf + r, size -r, ", FPU_MAC");
2704     }
2705
2706   if (has_fpu)
2707     {
2708       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2709         {
2710         case E_NDS32_FPU_REG_8SP_4DP:
2711           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2712           break;
2713         case E_NDS32_FPU_REG_16SP_8DP:
2714           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2715           break;
2716         case E_NDS32_FPU_REG_32SP_16DP:
2717           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2718           break;
2719         case E_NDS32_FPU_REG_32SP_32DP:
2720           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2721           break;
2722         }
2723     }
2724
2725   if (config & E_NDS32_HAS_AUDIO_INST)
2726     r += snprintf (buf + r, size -r, ", AUDIO");
2727
2728   if (config & E_NDS32_HAS_STRING_INST)
2729     r += snprintf (buf + r, size -r, ", STR");
2730
2731   if (config & E_NDS32_HAS_REDUCED_REGS)
2732     r += snprintf (buf + r, size -r, ", 16REG");
2733
2734   if (config & E_NDS32_HAS_VIDEO_INST)
2735     {
2736       if (version <= E_NDS32_ELF_VER_1_3)
2737         r += snprintf (buf + r, size -r, ", VIDEO");
2738       else
2739         r += snprintf (buf + r, size -r, ", SATURATION");
2740     }
2741
2742   if (config & E_NDS32_HAS_ENCRIPT_INST)
2743     r += snprintf (buf + r, size -r, ", ENCRP");
2744
2745   if (config & E_NDS32_HAS_L2C_INST)
2746     r += snprintf (buf + r, size -r, ", L2C");
2747 }
2748
2749 static char *
2750 get_machine_flags (unsigned e_flags, unsigned e_machine)
2751 {
2752   static char buf[1024];
2753
2754   buf[0] = '\0';
2755
2756   if (e_flags)
2757     {
2758       switch (e_machine)
2759         {
2760         default:
2761           break;
2762
2763         case EM_ARM:
2764           decode_ARM_machine_flags (e_flags, buf);
2765           break;
2766
2767         case EM_AVR:
2768           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2769           break;
2770
2771         case EM_BLACKFIN:
2772           if (e_flags & EF_BFIN_PIC)
2773             strcat (buf, ", PIC");
2774
2775           if (e_flags & EF_BFIN_FDPIC)
2776             strcat (buf, ", FDPIC");
2777
2778           if (e_flags & EF_BFIN_CODE_IN_L1)
2779             strcat (buf, ", code in L1");
2780
2781           if (e_flags & EF_BFIN_DATA_IN_L1)
2782             strcat (buf, ", data in L1");
2783
2784           break;
2785
2786         case EM_CYGNUS_FRV:
2787           switch (e_flags & EF_FRV_CPU_MASK)
2788             {
2789             case EF_FRV_CPU_GENERIC:
2790               break;
2791
2792             default:
2793               strcat (buf, ", fr???");
2794               break;
2795
2796             case EF_FRV_CPU_FR300:
2797               strcat (buf, ", fr300");
2798               break;
2799
2800             case EF_FRV_CPU_FR400:
2801               strcat (buf, ", fr400");
2802               break;
2803             case EF_FRV_CPU_FR405:
2804               strcat (buf, ", fr405");
2805               break;
2806
2807             case EF_FRV_CPU_FR450:
2808               strcat (buf, ", fr450");
2809               break;
2810
2811             case EF_FRV_CPU_FR500:
2812               strcat (buf, ", fr500");
2813               break;
2814             case EF_FRV_CPU_FR550:
2815               strcat (buf, ", fr550");
2816               break;
2817
2818             case EF_FRV_CPU_SIMPLE:
2819               strcat (buf, ", simple");
2820               break;
2821             case EF_FRV_CPU_TOMCAT:
2822               strcat (buf, ", tomcat");
2823               break;
2824             }
2825           break;
2826
2827         case EM_68K:
2828           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2829             strcat (buf, ", m68000");
2830           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2831             strcat (buf, ", cpu32");
2832           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2833             strcat (buf, ", fido_a");
2834           else
2835             {
2836               char const * isa = _("unknown");
2837               char const * mac = _("unknown mac");
2838               char const * additional = NULL;
2839
2840               switch (e_flags & EF_M68K_CF_ISA_MASK)
2841                 {
2842                 case EF_M68K_CF_ISA_A_NODIV:
2843                   isa = "A";
2844                   additional = ", nodiv";
2845                   break;
2846                 case EF_M68K_CF_ISA_A:
2847                   isa = "A";
2848                   break;
2849                 case EF_M68K_CF_ISA_A_PLUS:
2850                   isa = "A+";
2851                   break;
2852                 case EF_M68K_CF_ISA_B_NOUSP:
2853                   isa = "B";
2854                   additional = ", nousp";
2855                   break;
2856                 case EF_M68K_CF_ISA_B:
2857                   isa = "B";
2858                   break;
2859                 case EF_M68K_CF_ISA_C:
2860                   isa = "C";
2861                   break;
2862                 case EF_M68K_CF_ISA_C_NODIV:
2863                   isa = "C";
2864                   additional = ", nodiv";
2865                   break;
2866                 }
2867               strcat (buf, ", cf, isa ");
2868               strcat (buf, isa);
2869               if (additional)
2870                 strcat (buf, additional);
2871               if (e_flags & EF_M68K_CF_FLOAT)
2872                 strcat (buf, ", float");
2873               switch (e_flags & EF_M68K_CF_MAC_MASK)
2874                 {
2875                 case 0:
2876                   mac = NULL;
2877                   break;
2878                 case EF_M68K_CF_MAC:
2879                   mac = "mac";
2880                   break;
2881                 case EF_M68K_CF_EMAC:
2882                   mac = "emac";
2883                   break;
2884                 case EF_M68K_CF_EMAC_B:
2885                   mac = "emac_b";
2886                   break;
2887                 }
2888               if (mac)
2889                 {
2890                   strcat (buf, ", ");
2891                   strcat (buf, mac);
2892                 }
2893             }
2894           break;
2895
2896         case EM_CYGNUS_MEP:
2897           switch (e_flags & EF_MEP_CPU_MASK)
2898             {
2899             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2900             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2901             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2902             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2903             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2904             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2905             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2906             }
2907
2908           switch (e_flags & EF_MEP_COP_MASK)
2909             {
2910             case EF_MEP_COP_NONE: break;
2911             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2912             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2913             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2914             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2915             default: strcat (buf, _("<unknown MeP copro type>")); break;
2916             }
2917
2918           if (e_flags & EF_MEP_LIBRARY)
2919             strcat (buf, ", Built for Library");
2920
2921           if (e_flags & EF_MEP_INDEX_MASK)
2922             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2923                      e_flags & EF_MEP_INDEX_MASK);
2924
2925           if (e_flags & ~ EF_MEP_ALL_FLAGS)
2926             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2927                      e_flags & ~ EF_MEP_ALL_FLAGS);
2928           break;
2929
2930         case EM_PPC:
2931           if (e_flags & EF_PPC_EMB)
2932             strcat (buf, ", emb");
2933
2934           if (e_flags & EF_PPC_RELOCATABLE)
2935             strcat (buf, _(", relocatable"));
2936
2937           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2938             strcat (buf, _(", relocatable-lib"));
2939           break;
2940
2941         case EM_PPC64:
2942           if (e_flags & EF_PPC64_ABI)
2943             {
2944               char abi[] = ", abiv0";
2945
2946               abi[6] += e_flags & EF_PPC64_ABI;
2947               strcat (buf, abi);
2948             }
2949           break;
2950
2951         case EM_V800:
2952           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2953             strcat (buf, ", RH850 ABI");
2954
2955           if (e_flags & EF_V800_850E3)
2956             strcat (buf, ", V3 architecture");
2957
2958           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2959             strcat (buf, ", FPU not used");
2960
2961           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2962             strcat (buf, ", regmode: COMMON");
2963
2964           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2965             strcat (buf, ", r4 not used");
2966
2967           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2968             strcat (buf, ", r30 not used");
2969
2970           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2971             strcat (buf, ", r5 not used");
2972
2973           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2974             strcat (buf, ", r2 not used");
2975
2976           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2977             {
2978               switch (e_flags & - e_flags)
2979                 {
2980                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2981                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2982                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2983                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2984                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2985                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2986                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2987                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2988                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2989                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2990                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2991                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2992                 default: break;
2993                 }
2994             }
2995           break;
2996
2997         case EM_V850:
2998         case EM_CYGNUS_V850:
2999           switch (e_flags & EF_V850_ARCH)
3000             {
3001             case E_V850E3V5_ARCH:
3002               strcat (buf, ", v850e3v5");
3003               break;
3004             case E_V850E2V3_ARCH:
3005               strcat (buf, ", v850e2v3");
3006               break;
3007             case E_V850E2_ARCH:
3008               strcat (buf, ", v850e2");
3009               break;
3010             case E_V850E1_ARCH:
3011               strcat (buf, ", v850e1");
3012               break;
3013             case E_V850E_ARCH:
3014               strcat (buf, ", v850e");
3015               break;
3016             case E_V850_ARCH:
3017               strcat (buf, ", v850");
3018               break;
3019             default:
3020               strcat (buf, _(", unknown v850 architecture variant"));
3021               break;
3022             }
3023           break;
3024
3025         case EM_M32R:
3026         case EM_CYGNUS_M32R:
3027           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3028             strcat (buf, ", m32r");
3029           break;
3030
3031         case EM_MIPS:
3032         case EM_MIPS_RS3_LE:
3033           if (e_flags & EF_MIPS_NOREORDER)
3034             strcat (buf, ", noreorder");
3035
3036           if (e_flags & EF_MIPS_PIC)
3037             strcat (buf, ", pic");
3038
3039           if (e_flags & EF_MIPS_CPIC)
3040             strcat (buf, ", cpic");
3041
3042           if (e_flags & EF_MIPS_UCODE)
3043             strcat (buf, ", ugen_reserved");
3044
3045           if (e_flags & EF_MIPS_ABI2)
3046             strcat (buf, ", abi2");
3047
3048           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3049             strcat (buf, ", odk first");
3050
3051           if (e_flags & EF_MIPS_32BITMODE)
3052             strcat (buf, ", 32bitmode");
3053
3054           if (e_flags & EF_MIPS_NAN2008)
3055             strcat (buf, ", nan2008");
3056
3057           if (e_flags & EF_MIPS_FP64)
3058             strcat (buf, ", fp64");
3059
3060           switch ((e_flags & EF_MIPS_MACH))
3061             {
3062             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3063             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3064             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3065             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3066             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3067             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3068             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3069             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3070             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3071             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3072             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3073             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3074             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3075             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3076             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3077             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3078             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3079             case 0:
3080             /* We simply ignore the field in this case to avoid confusion:
3081                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3082                extension.  */
3083               break;
3084             default: strcat (buf, _(", unknown CPU")); break;
3085             }
3086
3087           switch ((e_flags & EF_MIPS_ABI))
3088             {
3089             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3090             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3091             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3092             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3093             case 0:
3094             /* We simply ignore the field in this case to avoid confusion:
3095                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3096                This means it is likely to be an o32 file, but not for
3097                sure.  */
3098               break;
3099             default: strcat (buf, _(", unknown ABI")); break;
3100             }
3101
3102           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3103             strcat (buf, ", mdmx");
3104
3105           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3106             strcat (buf, ", mips16");
3107
3108           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3109             strcat (buf, ", micromips");
3110
3111           switch ((e_flags & EF_MIPS_ARCH))
3112             {
3113             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3114             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3115             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3116             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3117             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3118             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3119             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3120             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3121             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3122             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3123             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3124             default: strcat (buf, _(", unknown ISA")); break;
3125             }
3126           break;
3127
3128         case EM_NDS32:
3129           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3130           break;
3131
3132         case EM_SH:
3133           switch ((e_flags & EF_SH_MACH_MASK))
3134             {
3135             case EF_SH1: strcat (buf, ", sh1"); break;
3136             case EF_SH2: strcat (buf, ", sh2"); break;
3137             case EF_SH3: strcat (buf, ", sh3"); break;
3138             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3139             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3140             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3141             case EF_SH3E: strcat (buf, ", sh3e"); break;
3142             case EF_SH4: strcat (buf, ", sh4"); break;
3143             case EF_SH5: strcat (buf, ", sh5"); break;
3144             case EF_SH2E: strcat (buf, ", sh2e"); break;
3145             case EF_SH4A: strcat (buf, ", sh4a"); break;
3146             case EF_SH2A: strcat (buf, ", sh2a"); break;
3147             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3148             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3149             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3150             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3151             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3152             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3153             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3154             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3155             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3156             default: strcat (buf, _(", unknown ISA")); break;
3157             }
3158
3159           if (e_flags & EF_SH_PIC)
3160             strcat (buf, ", pic");
3161
3162           if (e_flags & EF_SH_FDPIC)
3163             strcat (buf, ", fdpic");
3164           break;
3165
3166         case EM_OR1K:
3167           if (e_flags & EF_OR1K_NODELAY)
3168             strcat (buf, ", no delay");
3169           break;
3170
3171         case EM_SPARCV9:
3172           if (e_flags & EF_SPARC_32PLUS)
3173             strcat (buf, ", v8+");
3174
3175           if (e_flags & EF_SPARC_SUN_US1)
3176             strcat (buf, ", ultrasparcI");
3177
3178           if (e_flags & EF_SPARC_SUN_US3)
3179             strcat (buf, ", ultrasparcIII");
3180
3181           if (e_flags & EF_SPARC_HAL_R1)
3182             strcat (buf, ", halr1");
3183
3184           if (e_flags & EF_SPARC_LEDATA)
3185             strcat (buf, ", ledata");
3186
3187           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3188             strcat (buf, ", tso");
3189
3190           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3191             strcat (buf, ", pso");
3192
3193           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3194             strcat (buf, ", rmo");
3195           break;
3196
3197         case EM_PARISC:
3198           switch (e_flags & EF_PARISC_ARCH)
3199             {
3200             case EFA_PARISC_1_0:
3201               strcpy (buf, ", PA-RISC 1.0");
3202               break;
3203             case EFA_PARISC_1_1:
3204               strcpy (buf, ", PA-RISC 1.1");
3205               break;
3206             case EFA_PARISC_2_0:
3207               strcpy (buf, ", PA-RISC 2.0");
3208               break;
3209             default:
3210               break;
3211             }
3212           if (e_flags & EF_PARISC_TRAPNIL)
3213             strcat (buf, ", trapnil");
3214           if (e_flags & EF_PARISC_EXT)
3215             strcat (buf, ", ext");
3216           if (e_flags & EF_PARISC_LSB)
3217             strcat (buf, ", lsb");
3218           if (e_flags & EF_PARISC_WIDE)
3219             strcat (buf, ", wide");
3220           if (e_flags & EF_PARISC_NO_KABP)
3221             strcat (buf, ", no kabp");
3222           if (e_flags & EF_PARISC_LAZYSWAP)
3223             strcat (buf, ", lazyswap");
3224           break;
3225
3226         case EM_PJ:
3227         case EM_PJ_OLD:
3228           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3229             strcat (buf, ", new calling convention");
3230
3231           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3232             strcat (buf, ", gnu calling convention");
3233           break;
3234
3235         case EM_IA_64:
3236           if ((e_flags & EF_IA_64_ABI64))
3237             strcat (buf, ", 64-bit");
3238           else
3239             strcat (buf, ", 32-bit");
3240           if ((e_flags & EF_IA_64_REDUCEDFP))
3241             strcat (buf, ", reduced fp model");
3242           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3243             strcat (buf, ", no function descriptors, constant gp");
3244           else if ((e_flags & EF_IA_64_CONS_GP))
3245             strcat (buf, ", constant gp");
3246           if ((e_flags & EF_IA_64_ABSOLUTE))
3247             strcat (buf, ", absolute");
3248           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3249             {
3250               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3251                 strcat (buf, ", vms_linkages");
3252               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3253                 {
3254                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3255                   break;
3256                 case EF_IA_64_VMS_COMCOD_WARNING:
3257                   strcat (buf, ", warning");
3258                   break;
3259                 case EF_IA_64_VMS_COMCOD_ERROR:
3260                   strcat (buf, ", error");
3261                   break;
3262                 case EF_IA_64_VMS_COMCOD_ABORT:
3263                   strcat (buf, ", abort");
3264                   break;
3265                 default:
3266                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3267                         e_flags & EF_IA_64_VMS_COMCOD);
3268                   strcat (buf, ", <unknown>");
3269                 }
3270             }
3271           break;
3272
3273         case EM_VAX:
3274           if ((e_flags & EF_VAX_NONPIC))
3275             strcat (buf, ", non-PIC");
3276           if ((e_flags & EF_VAX_DFLOAT))
3277             strcat (buf, ", D-Float");
3278           if ((e_flags & EF_VAX_GFLOAT))
3279             strcat (buf, ", G-Float");
3280           break;
3281
3282         case EM_VISIUM:
3283           if (e_flags & EF_VISIUM_ARCH_MCM)
3284             strcat (buf, ", mcm");
3285           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3286             strcat (buf, ", mcm24");
3287           if (e_flags & EF_VISIUM_ARCH_GR6)
3288             strcat (buf, ", gr6");
3289           break;
3290
3291         case EM_RL78:
3292           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3293             {
3294             case E_FLAG_RL78_ANY_CPU: break;
3295             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3296             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3297             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3298             }
3299           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3300             strcat (buf, ", 64-bit doubles");
3301           break;
3302
3303         case EM_RX:
3304           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3305             strcat (buf, ", 64-bit doubles");
3306           if (e_flags & E_FLAG_RX_DSP)
3307             strcat (buf, ", dsp");
3308           if (e_flags & E_FLAG_RX_PID)
3309             strcat (buf, ", pid");
3310           if (e_flags & E_FLAG_RX_ABI)
3311             strcat (buf, ", RX ABI");
3312           if (e_flags & E_FLAG_RX_SINSNS_SET)
3313             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3314                     ? ", uses String instructions" : ", bans String instructions");
3315           break;
3316
3317         case EM_S390:
3318           if (e_flags & EF_S390_HIGH_GPRS)
3319             strcat (buf, ", highgprs");
3320           break;
3321
3322         case EM_TI_C6000:
3323           if ((e_flags & EF_C6000_REL))
3324             strcat (buf, ", relocatable module");
3325           break;
3326
3327         case EM_MSP430:
3328           strcat (buf, _(": architecture variant: "));
3329           switch (e_flags & EF_MSP430_MACH)
3330             {
3331             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3332             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3333             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3334             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3335             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3336             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3337             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3338             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3339             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3340             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3341             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3342             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3343             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3344             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3345             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3346             default:
3347               strcat (buf, _(": unknown")); break;
3348             }
3349
3350           if (e_flags & ~ EF_MSP430_MACH)
3351             strcat (buf, _(": unknown extra flag bits also present"));
3352         }
3353     }
3354
3355   return buf;
3356 }
3357
3358 static const char *
3359 get_osabi_name (unsigned int osabi)
3360 {
3361   static char buff[32];
3362
3363   switch (osabi)
3364     {
3365     case ELFOSABI_NONE:         return "UNIX - System V";
3366     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3367     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3368     case ELFOSABI_GNU:          return "UNIX - GNU";
3369     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3370     case ELFOSABI_AIX:          return "UNIX - AIX";
3371     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3372     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3373     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3374     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3375     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3376     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3377     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3378     case ELFOSABI_AROS:         return "AROS";
3379     case ELFOSABI_FENIXOS:      return "FenixOS";
3380     default:
3381       if (osabi >= 64)
3382         switch (elf_header.e_machine)
3383           {
3384           case EM_ARM:
3385             switch (osabi)
3386               {
3387               case ELFOSABI_ARM:        return "ARM";
3388               default:
3389                 break;
3390               }
3391             break;
3392
3393           case EM_MSP430:
3394           case EM_MSP430_OLD:
3395           case EM_VISIUM:
3396             switch (osabi)
3397               {
3398               case ELFOSABI_STANDALONE: return _("Standalone App");
3399               default:
3400                 break;
3401               }
3402             break;
3403
3404           case EM_TI_C6000:
3405             switch (osabi)
3406               {
3407               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3408               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3409               default:
3410                 break;
3411               }
3412             break;
3413
3414           default:
3415             break;
3416           }
3417       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3418       return buff;
3419     }
3420 }
3421
3422 static const char *
3423 get_aarch64_segment_type (unsigned long type)
3424 {
3425   switch (type)
3426     {
3427     case PT_AARCH64_ARCHEXT:
3428       return "AARCH64_ARCHEXT";
3429     default:
3430       break;
3431     }
3432
3433   return NULL;
3434 }
3435
3436 static const char *
3437 get_arm_segment_type (unsigned long type)
3438 {
3439   switch (type)
3440     {
3441     case PT_ARM_EXIDX:
3442       return "EXIDX";
3443     default:
3444       break;
3445     }
3446
3447   return NULL;
3448 }
3449
3450 static const char *
3451 get_mips_segment_type (unsigned long type)
3452 {
3453   switch (type)
3454     {
3455     case PT_MIPS_REGINFO:
3456       return "REGINFO";
3457     case PT_MIPS_RTPROC:
3458       return "RTPROC";
3459     case PT_MIPS_OPTIONS:
3460       return "OPTIONS";
3461     case PT_MIPS_ABIFLAGS:
3462       return "ABIFLAGS";
3463     default:
3464       break;
3465     }
3466
3467   return NULL;
3468 }
3469
3470 static const char *
3471 get_parisc_segment_type (unsigned long type)
3472 {
3473   switch (type)
3474     {
3475     case PT_HP_TLS:             return "HP_TLS";
3476     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3477     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3478     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3479     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3480     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3481     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3482     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3483     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3484     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3485     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3486     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3487     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3488     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3489     case PT_HP_STACK:           return "HP_STACK";
3490     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3491     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3492     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3493     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3494     default:
3495       break;
3496     }
3497
3498   return NULL;
3499 }
3500
3501 static const char *
3502 get_ia64_segment_type (unsigned long type)
3503 {
3504   switch (type)
3505     {
3506     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3507     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3508     case PT_HP_TLS:             return "HP_TLS";
3509     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3510     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3511     case PT_IA_64_HP_STACK:     return "HP_STACK";
3512     default:
3513       break;
3514     }
3515
3516   return NULL;
3517 }
3518
3519 static const char *
3520 get_tic6x_segment_type (unsigned long type)
3521 {
3522   switch (type)
3523     {
3524     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3525     default:
3526       break;
3527     }
3528
3529   return NULL;
3530 }
3531
3532 static const char *
3533 get_segment_type (unsigned long p_type)
3534 {
3535   static char buff[32];
3536
3537   switch (p_type)
3538     {
3539     case PT_NULL:       return "NULL";
3540     case PT_LOAD:       return "LOAD";
3541     case PT_DYNAMIC:    return "DYNAMIC";
3542     case PT_INTERP:     return "INTERP";
3543     case PT_NOTE:       return "NOTE";
3544     case PT_SHLIB:      return "SHLIB";
3545     case PT_PHDR:       return "PHDR";
3546     case PT_TLS:        return "TLS";
3547
3548     case PT_GNU_EH_FRAME:
3549                         return "GNU_EH_FRAME";
3550     case PT_GNU_STACK:  return "GNU_STACK";
3551     case PT_GNU_RELRO:  return "GNU_RELRO";
3552
3553     default:
3554       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3555         {
3556           const char * result;
3557
3558           switch (elf_header.e_machine)
3559             {
3560             case EM_AARCH64:
3561               result = get_aarch64_segment_type (p_type);
3562               break;
3563             case EM_ARM:
3564               result = get_arm_segment_type (p_type);
3565               break;
3566             case EM_MIPS:
3567             case EM_MIPS_RS3_LE:
3568               result = get_mips_segment_type (p_type);
3569               break;
3570             case EM_PARISC:
3571               result = get_parisc_segment_type (p_type);
3572               break;
3573             case EM_IA_64:
3574               result = get_ia64_segment_type (p_type);
3575               break;
3576             case EM_TI_C6000:
3577               result = get_tic6x_segment_type (p_type);
3578               break;
3579             default:
3580               result = NULL;
3581               break;
3582             }
3583
3584           if (result != NULL)
3585             return result;
3586
3587           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3588         }
3589       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3590         {
3591           const char * result;
3592
3593           switch (elf_header.e_machine)
3594             {
3595             case EM_PARISC:
3596               result = get_parisc_segment_type (p_type);
3597               break;
3598             case EM_IA_64:
3599               result = get_ia64_segment_type (p_type);
3600               break;
3601             default:
3602               result = NULL;
3603               break;
3604             }
3605
3606           if (result != NULL)
3607             return result;
3608
3609           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3610         }
3611       else
3612         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3613
3614       return buff;
3615     }
3616 }
3617
3618 static const char *
3619 get_mips_section_type_name (unsigned int sh_type)
3620 {
3621   switch (sh_type)
3622     {
3623     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3624     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3625     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3626     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3627     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3628     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3629     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3630     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3631     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3632     case SHT_MIPS_RELD:          return "MIPS_RELD";
3633     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3634     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3635     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3636     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3637     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3638     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3639     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3640     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3641     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3642     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3643     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3644     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3645     case SHT_MIPS_LINE:          return "MIPS_LINE";
3646     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3647     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3648     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3649     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3650     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3651     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3652     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3653     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3654     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3655     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3656     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3657     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3658     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3659     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3660     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3661     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3662     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3663     default:
3664       break;
3665     }
3666   return NULL;
3667 }
3668
3669 static const char *
3670 get_parisc_section_type_name (unsigned int sh_type)
3671 {
3672   switch (sh_type)
3673     {
3674     case SHT_PARISC_EXT:        return "PARISC_EXT";
3675     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3676     case SHT_PARISC_DOC:        return "PARISC_DOC";
3677     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3678     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3679     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3680     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3681     default:
3682       break;
3683     }
3684   return NULL;
3685 }
3686
3687 static const char *
3688 get_ia64_section_type_name (unsigned int sh_type)
3689 {
3690   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3691   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3692     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3693
3694   switch (sh_type)
3695     {
3696     case SHT_IA_64_EXT:                return "IA_64_EXT";
3697     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3698     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3699     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3700     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3701     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3702     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3703     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3704     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3705     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3706     default:
3707       break;
3708     }
3709   return NULL;
3710 }
3711
3712 static const char *
3713 get_x86_64_section_type_name (unsigned int sh_type)
3714 {
3715   switch (sh_type)
3716     {
3717     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3718     default:
3719       break;
3720     }
3721   return NULL;
3722 }
3723
3724 static const char *
3725 get_aarch64_section_type_name (unsigned int sh_type)
3726 {
3727   switch (sh_type)
3728     {
3729     case SHT_AARCH64_ATTRIBUTES:
3730       return "AARCH64_ATTRIBUTES";
3731     default:
3732       break;
3733     }
3734   return NULL;
3735 }
3736
3737 static const char *
3738 get_arm_section_type_name (unsigned int sh_type)
3739 {
3740   switch (sh_type)
3741     {
3742     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3743     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3744     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3745     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3746     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3747     default:
3748       break;
3749     }
3750   return NULL;
3751 }
3752
3753 static const char *
3754 get_tic6x_section_type_name (unsigned int sh_type)
3755 {
3756   switch (sh_type)
3757     {
3758     case SHT_C6000_UNWIND:
3759       return "C6000_UNWIND";
3760     case SHT_C6000_PREEMPTMAP:
3761       return "C6000_PREEMPTMAP";
3762     case SHT_C6000_ATTRIBUTES:
3763       return "C6000_ATTRIBUTES";
3764     case SHT_TI_ICODE:
3765       return "TI_ICODE";
3766     case SHT_TI_XREF:
3767       return "TI_XREF";
3768     case SHT_TI_HANDLER:
3769       return "TI_HANDLER";
3770     case SHT_TI_INITINFO:
3771       return "TI_INITINFO";
3772     case SHT_TI_PHATTRS:
3773       return "TI_PHATTRS";
3774     default:
3775       break;
3776     }
3777   return NULL;
3778 }
3779
3780 static const char *
3781 get_msp430x_section_type_name (unsigned int sh_type)
3782 {
3783   switch (sh_type)
3784     {
3785     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3786     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3787     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3788     default: return NULL;
3789     }
3790 }
3791
3792 static const char *
3793 get_v850_section_type_name (unsigned int sh_type)
3794 {
3795   switch (sh_type)
3796     {
3797     case SHT_V850_SCOMMON: return "V850 Small Common";
3798     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3799     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3800     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3801     case SHT_RENESAS_INFO: return "RENESAS INFO";
3802     default: return NULL;
3803     }
3804 }
3805
3806 static const char *
3807 get_section_type_name (unsigned int sh_type)
3808 {
3809   static char buff[32];
3810
3811   switch (sh_type)
3812     {
3813     case SHT_NULL:              return "NULL";
3814     case SHT_PROGBITS:          return "PROGBITS";
3815     case SHT_SYMTAB:            return "SYMTAB";
3816     case SHT_STRTAB:            return "STRTAB";
3817     case SHT_RELA:              return "RELA";
3818     case SHT_HASH:              return "HASH";
3819     case SHT_DYNAMIC:           return "DYNAMIC";
3820     case SHT_NOTE:              return "NOTE";
3821     case SHT_NOBITS:            return "NOBITS";
3822     case SHT_REL:               return "REL";
3823     case SHT_SHLIB:             return "SHLIB";
3824     case SHT_DYNSYM:            return "DYNSYM";
3825     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3826     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3827     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3828     case SHT_GNU_HASH:          return "GNU_HASH";
3829     case SHT_GROUP:             return "GROUP";
3830     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3831     case SHT_GNU_verdef:        return "VERDEF";
3832     case SHT_GNU_verneed:       return "VERNEED";
3833     case SHT_GNU_versym:        return "VERSYM";
3834     case 0x6ffffff0:            return "VERSYM";
3835     case 0x6ffffffc:            return "VERDEF";
3836     case 0x7ffffffd:            return "AUXILIARY";
3837     case 0x7fffffff:            return "FILTER";
3838     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3839
3840     default:
3841       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3842         {
3843           const char * result;
3844
3845           switch (elf_header.e_machine)
3846             {
3847             case EM_MIPS:
3848             case EM_MIPS_RS3_LE:
3849               result = get_mips_section_type_name (sh_type);
3850               break;
3851             case EM_PARISC:
3852               result = get_parisc_section_type_name (sh_type);
3853               break;
3854             case EM_IA_64:
3855               result = get_ia64_section_type_name (sh_type);
3856               break;
3857             case EM_X86_64:
3858             case EM_L1OM:
3859             case EM_K1OM:
3860               result = get_x86_64_section_type_name (sh_type);
3861               break;
3862             case EM_AARCH64:
3863               result = get_aarch64_section_type_name (sh_type);
3864               break;
3865             case EM_ARM:
3866               result = get_arm_section_type_name (sh_type);
3867               break;
3868             case EM_TI_C6000:
3869               result = get_tic6x_section_type_name (sh_type);
3870               break;
3871             case EM_MSP430:
3872               result = get_msp430x_section_type_name (sh_type);
3873               break;
3874             case EM_V800:
3875             case EM_V850:
3876             case EM_CYGNUS_V850:
3877               result = get_v850_section_type_name (sh_type);
3878               break;
3879             default:
3880               result = NULL;
3881               break;
3882             }
3883
3884           if (result != NULL)
3885             return result;
3886
3887           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3888         }
3889       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3890         {
3891           const char * result;
3892
3893           switch (elf_header.e_machine)
3894             {
3895             case EM_IA_64:
3896               result = get_ia64_section_type_name (sh_type);
3897               break;
3898             default:
3899               result = NULL;
3900               break;
3901             }
3902
3903           if (result != NULL)
3904             return result;
3905
3906           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3907         }
3908       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3909         {
3910           switch (elf_header.e_machine)
3911             {
3912             case EM_V800:
3913             case EM_V850:
3914             case EM_CYGNUS_V850:
3915               return get_v850_section_type_name (sh_type);
3916             default:
3917               break;
3918             }
3919
3920           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3921         }
3922       else
3923         /* This message is probably going to be displayed in a 15
3924            character wide field, so put the hex value first.  */
3925         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3926
3927       return buff;
3928     }
3929 }
3930
3931 #define OPTION_DEBUG_DUMP       512
3932 #define OPTION_DYN_SYMS         513
3933 #define OPTION_DWARF_DEPTH      514
3934 #define OPTION_DWARF_START      515
3935 #define OPTION_DWARF_CHECK      516
3936
3937 static struct option options[] =
3938 {
3939   {"all",              no_argument, 0, 'a'},
3940   {"file-header",      no_argument, 0, 'h'},
3941   {"program-headers",  no_argument, 0, 'l'},
3942   {"headers",          no_argument, 0, 'e'},
3943   {"histogram",        no_argument, 0, 'I'},
3944   {"segments",         no_argument, 0, 'l'},
3945   {"sections",         no_argument, 0, 'S'},
3946   {"section-headers",  no_argument, 0, 'S'},
3947   {"section-groups",   no_argument, 0, 'g'},
3948   {"section-details",  no_argument, 0, 't'},
3949   {"full-section-name",no_argument, 0, 'N'},
3950   {"symbols",          no_argument, 0, 's'},
3951   {"syms",             no_argument, 0, 's'},
3952   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3953   {"relocs",           no_argument, 0, 'r'},
3954   {"notes",            no_argument, 0, 'n'},
3955   {"dynamic",          no_argument, 0, 'd'},
3956   {"arch-specific",    no_argument, 0, 'A'},
3957   {"version-info",     no_argument, 0, 'V'},
3958   {"use-dynamic",      no_argument, 0, 'D'},
3959   {"unwind",           no_argument, 0, 'u'},
3960   {"archive-index",    no_argument, 0, 'c'},
3961   {"hex-dump",         required_argument, 0, 'x'},
3962   {"relocated-dump",   required_argument, 0, 'R'},
3963   {"string-dump",      required_argument, 0, 'p'},
3964   {"decompress",       no_argument, 0, 'z'},
3965 #ifdef SUPPORT_DISASSEMBLY
3966   {"instruction-dump", required_argument, 0, 'i'},
3967 #endif
3968   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3969
3970   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3971   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3972   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3973
3974   {"version",          no_argument, 0, 'v'},
3975   {"wide",             no_argument, 0, 'W'},
3976   {"help",             no_argument, 0, 'H'},
3977   {0,                  no_argument, 0, 0}
3978 };
3979
3980 static void
3981 usage (FILE * stream)
3982 {
3983   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3984   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3985   fprintf (stream, _(" Options are:\n\
3986   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3987   -h --file-header       Display the ELF file header\n\
3988   -l --program-headers   Display the program headers\n\
3989      --segments          An alias for --program-headers\n\
3990   -S --section-headers   Display the sections' header\n\
3991      --sections          An alias for --section-headers\n\
3992   -g --section-groups    Display the section groups\n\
3993   -t --section-details   Display the section details\n\
3994   -e --headers           Equivalent to: -h -l -S\n\
3995   -s --syms              Display the symbol table\n\
3996      --symbols           An alias for --syms\n\
3997   --dyn-syms             Display the dynamic symbol table\n\
3998   -n --notes             Display the core notes (if present)\n\
3999   -r --relocs            Display the relocations (if present)\n\
4000   -u --unwind            Display the unwind info (if present)\n\
4001   -d --dynamic           Display the dynamic section (if present)\n\
4002   -V --version-info      Display the version sections (if present)\n\
4003   -A --arch-specific     Display architecture specific information (if any)\n\
4004   -c --archive-index     Display the symbol/file index in an archive\n\
4005   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4006   -x --hex-dump=<number|name>\n\
4007                          Dump the contents of section <number|name> as bytes\n\
4008   -p --string-dump=<number|name>\n\
4009                          Dump the contents of section <number|name> as strings\n\
4010   -R --relocated-dump=<number|name>\n\
4011                          Dump the contents of section <number|name> as relocated bytes\n\
4012   -z --decompress        Decompress section before dumping it\n\
4013   -w[lLiaprmfFsoRt] or\n\
4014   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4015                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4016                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4017                =addr,=cu_index]\n\
4018                          Display the contents of DWARF2 debug sections\n"));
4019   fprintf (stream, _("\
4020   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4021   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4022                          or deeper\n"));
4023 #ifdef SUPPORT_DISASSEMBLY
4024   fprintf (stream, _("\
4025   -i --instruction-dump=<number|name>\n\
4026                          Disassemble the contents of section <number|name>\n"));
4027 #endif
4028   fprintf (stream, _("\
4029   -I --histogram         Display histogram of bucket list lengths\n\
4030   -W --wide              Allow output width to exceed 80 characters\n\
4031   @<file>                Read options from <file>\n\
4032   -H --help              Display this information\n\
4033   -v --version           Display the version number of readelf\n"));
4034
4035   if (REPORT_BUGS_TO[0] && stream == stdout)
4036     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4037
4038   exit (stream == stdout ? 0 : 1);
4039 }
4040
4041 /* Record the fact that the user wants the contents of section number
4042    SECTION to be displayed using the method(s) encoded as flags bits
4043    in TYPE.  Note, TYPE can be zero if we are creating the array for
4044    the first time.  */
4045
4046 static void
4047 request_dump_bynumber (unsigned int section, dump_type type)
4048 {
4049   if (section >= num_dump_sects)
4050     {
4051       dump_type * new_dump_sects;
4052
4053       new_dump_sects = (dump_type *) calloc (section + 1,
4054                                              sizeof (* dump_sects));
4055
4056       if (new_dump_sects == NULL)
4057         error (_("Out of memory allocating dump request table.\n"));
4058       else
4059         {
4060           /* Copy current flag settings.  */
4061           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4062
4063           free (dump_sects);
4064
4065           dump_sects = new_dump_sects;
4066           num_dump_sects = section + 1;
4067         }
4068     }
4069
4070   if (dump_sects)
4071     dump_sects[section] |= type;
4072
4073   return;
4074 }
4075
4076 /* Request a dump by section name.  */
4077
4078 static void
4079 request_dump_byname (const char * section, dump_type type)
4080 {
4081   struct dump_list_entry * new_request;
4082
4083   new_request = (struct dump_list_entry *)
4084       malloc (sizeof (struct dump_list_entry));
4085   if (!new_request)
4086     error (_("Out of memory allocating dump request table.\n"));
4087
4088   new_request->name = strdup (section);
4089   if (!new_request->name)
4090     error (_("Out of memory allocating dump request table.\n"));
4091
4092   new_request->type = type;
4093
4094   new_request->next = dump_sects_byname;
4095   dump_sects_byname = new_request;
4096 }
4097
4098 static inline void
4099 request_dump (dump_type type)
4100 {
4101   int section;
4102   char * cp;
4103
4104   do_dump++;
4105   section = strtoul (optarg, & cp, 0);
4106
4107   if (! *cp && section >= 0)
4108     request_dump_bynumber (section, type);
4109   else
4110     request_dump_byname (optarg, type);
4111 }
4112
4113
4114 static void
4115 parse_args (int argc, char ** argv)
4116 {
4117   int c;
4118
4119   if (argc < 2)
4120     usage (stderr);
4121
4122   while ((c = getopt_long
4123           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4124     {
4125       switch (c)
4126         {
4127         case 0:
4128           /* Long options.  */
4129           break;
4130         case 'H':
4131           usage (stdout);
4132           break;
4133
4134         case 'a':
4135           do_syms++;
4136           do_reloc++;
4137           do_unwind++;
4138           do_dynamic++;
4139           do_header++;
4140           do_sections++;
4141           do_section_groups++;
4142           do_segments++;
4143           do_version++;
4144           do_histogram++;
4145           do_arch++;
4146           do_notes++;
4147           break;
4148         case 'g':
4149           do_section_groups++;
4150           break;
4151         case 't':
4152         case 'N':
4153           do_sections++;
4154           do_section_details++;
4155           break;
4156         case 'e':
4157           do_header++;
4158           do_sections++;
4159           do_segments++;
4160           break;
4161         case 'A':
4162           do_arch++;
4163           break;
4164         case 'D':
4165           do_using_dynamic++;
4166           break;
4167         case 'r':
4168           do_reloc++;
4169           break;
4170         case 'u':
4171           do_unwind++;
4172           break;
4173         case 'h':
4174           do_header++;
4175           break;
4176         case 'l':
4177           do_segments++;
4178           break;
4179         case 's':
4180           do_syms++;
4181           break;
4182         case 'S':
4183           do_sections++;
4184           break;
4185         case 'd':
4186           do_dynamic++;
4187           break;
4188         case 'I':
4189           do_histogram++;
4190           break;
4191         case 'n':
4192           do_notes++;
4193           break;
4194         case 'c':
4195           do_archive_index++;
4196           break;
4197         case 'x':
4198           request_dump (HEX_DUMP);
4199           break;
4200         case 'p':
4201           request_dump (STRING_DUMP);
4202           break;
4203         case 'R':
4204           request_dump (RELOC_DUMP);
4205           break;
4206         case 'z':
4207           decompress_dumps++;
4208           break;
4209         case 'w':
4210           do_dump++;
4211           if (optarg == 0)
4212             {
4213               do_debugging = 1;
4214               dwarf_select_sections_all ();
4215             }
4216           else
4217             {
4218               do_debugging = 0;
4219               dwarf_select_sections_by_letters (optarg);
4220             }
4221           break;
4222         case OPTION_DEBUG_DUMP:
4223           do_dump++;
4224           if (optarg == 0)
4225             do_debugging = 1;
4226           else
4227             {
4228               do_debugging = 0;
4229               dwarf_select_sections_by_names (optarg);
4230             }
4231           break;
4232         case OPTION_DWARF_DEPTH:
4233           {
4234             char *cp;
4235
4236             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4237           }
4238           break;
4239         case OPTION_DWARF_START:
4240           {
4241             char *cp;
4242
4243             dwarf_start_die = strtoul (optarg, & cp, 0);
4244           }
4245           break;
4246         case OPTION_DWARF_CHECK:
4247           dwarf_check = 1;
4248           break;
4249         case OPTION_DYN_SYMS:
4250           do_dyn_syms++;
4251           break;
4252 #ifdef SUPPORT_DISASSEMBLY
4253         case 'i':
4254           request_dump (DISASS_DUMP);
4255           break;
4256 #endif
4257         case 'v':
4258           print_version (program_name);
4259           break;
4260         case 'V':
4261           do_version++;
4262           break;
4263         case 'W':
4264           do_wide++;
4265           break;
4266         default:
4267           /* xgettext:c-format */
4268           error (_("Invalid option '-%c'\n"), c);
4269           /* Drop through.  */
4270         case '?':
4271           usage (stderr);
4272         }
4273     }
4274
4275   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4276       && !do_segments && !do_header && !do_dump && !do_version
4277       && !do_histogram && !do_debugging && !do_arch && !do_notes
4278       && !do_section_groups && !do_archive_index
4279       && !do_dyn_syms)
4280     usage (stderr);
4281 }
4282
4283 static const char *
4284 get_elf_class (unsigned int elf_class)
4285 {
4286   static char buff[32];
4287
4288   switch (elf_class)
4289     {
4290     case ELFCLASSNONE: return _("none");
4291     case ELFCLASS32:   return "ELF32";
4292     case ELFCLASS64:   return "ELF64";
4293     default:
4294       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4295       return buff;
4296     }
4297 }
4298
4299 static const char *
4300 get_data_encoding (unsigned int encoding)
4301 {
4302   static char buff[32];
4303
4304   switch (encoding)
4305     {
4306     case ELFDATANONE: return _("none");
4307     case ELFDATA2LSB: return _("2's complement, little endian");
4308     case ELFDATA2MSB: return _("2's complement, big endian");
4309     default:
4310       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4311       return buff;
4312     }
4313 }
4314
4315 /* Decode the data held in 'elf_header'.  */
4316
4317 static int
4318 process_file_header (void)
4319 {
4320   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4321       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4322       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4323       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4324     {
4325       error
4326         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4327       return 0;
4328     }
4329
4330   init_dwarf_regnames (elf_header.e_machine);
4331
4332   if (do_header)
4333     {
4334       int i;
4335
4336       printf (_("ELF Header:\n"));
4337       printf (_("  Magic:   "));
4338       for (i = 0; i < EI_NIDENT; i++)
4339         printf ("%2.2x ", elf_header.e_ident[i]);
4340       printf ("\n");
4341       printf (_("  Class:                             %s\n"),
4342               get_elf_class (elf_header.e_ident[EI_CLASS]));
4343       printf (_("  Data:                              %s\n"),
4344               get_data_encoding (elf_header.e_ident[EI_DATA]));
4345       printf (_("  Version:                           %d %s\n"),
4346               elf_header.e_ident[EI_VERSION],
4347               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4348                ? "(current)"
4349                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4350                   ? _("<unknown: %lx>")
4351                   : "")));
4352       printf (_("  OS/ABI:                            %s\n"),
4353               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4354       printf (_("  ABI Version:                       %d\n"),
4355               elf_header.e_ident[EI_ABIVERSION]);
4356       printf (_("  Type:                              %s\n"),
4357               get_file_type (elf_header.e_type));
4358       printf (_("  Machine:                           %s\n"),
4359               get_machine_name (elf_header.e_machine));
4360       printf (_("  Version:                           0x%lx\n"),
4361               (unsigned long) elf_header.e_version);
4362
4363       printf (_("  Entry point address:               "));
4364       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4365       printf (_("\n  Start of program headers:          "));
4366       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4367       printf (_(" (bytes into file)\n  Start of section headers:          "));
4368       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4369       printf (_(" (bytes into file)\n"));
4370
4371       printf (_("  Flags:                             0x%lx%s\n"),
4372               (unsigned long) elf_header.e_flags,
4373               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4374       printf (_("  Size of this header:               %ld (bytes)\n"),
4375               (long) elf_header.e_ehsize);
4376       printf (_("  Size of program headers:           %ld (bytes)\n"),
4377               (long) elf_header.e_phentsize);
4378       printf (_("  Number of program headers:         %ld"),
4379               (long) elf_header.e_phnum);
4380       if (section_headers != NULL
4381           && elf_header.e_phnum == PN_XNUM
4382           && section_headers[0].sh_info != 0)
4383         printf (" (%ld)", (long) section_headers[0].sh_info);
4384       putc ('\n', stdout);
4385       printf (_("  Size of section headers:           %ld (bytes)\n"),
4386               (long) elf_header.e_shentsize);
4387       printf (_("  Number of section headers:         %ld"),
4388               (long) elf_header.e_shnum);
4389       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4390         printf (" (%ld)", (long) section_headers[0].sh_size);
4391       putc ('\n', stdout);
4392       printf (_("  Section header string table index: %ld"),
4393               (long) elf_header.e_shstrndx);
4394       if (section_headers != NULL
4395           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4396         printf (" (%u)", section_headers[0].sh_link);
4397       else if (elf_header.e_shstrndx != SHN_UNDEF
4398                && elf_header.e_shstrndx >= elf_header.e_shnum)
4399         printf (_(" <corrupt: out of range>"));
4400       putc ('\n', stdout);
4401     }
4402
4403   if (section_headers != NULL)
4404     {
4405       if (elf_header.e_phnum == PN_XNUM
4406           && section_headers[0].sh_info != 0)
4407         elf_header.e_phnum = section_headers[0].sh_info;
4408       if (elf_header.e_shnum == SHN_UNDEF)
4409         elf_header.e_shnum = section_headers[0].sh_size;
4410       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4411         elf_header.e_shstrndx = section_headers[0].sh_link;
4412       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4413         elf_header.e_shstrndx = SHN_UNDEF;
4414       free (section_headers);
4415       section_headers = NULL;
4416     }
4417
4418   return 1;
4419 }
4420
4421 static bfd_boolean
4422 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4423 {
4424   Elf32_External_Phdr * phdrs;
4425   Elf32_External_Phdr * external;
4426   Elf_Internal_Phdr *   internal;
4427   unsigned int i;
4428   unsigned int size = elf_header.e_phentsize;
4429   unsigned int num  = elf_header.e_phnum;
4430
4431   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4432   if (size == 0 || num == 0)
4433     return FALSE;
4434   if (size < sizeof * phdrs)
4435     {
4436       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4437       return FALSE;
4438     }
4439   if (size > sizeof * phdrs)
4440     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4441
4442   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4443                                             size, num, _("program headers"));
4444   if (phdrs == NULL)
4445     return FALSE;
4446
4447   for (i = 0, internal = pheaders, external = phdrs;
4448        i < elf_header.e_phnum;
4449        i++, internal++, external++)
4450     {
4451       internal->p_type   = BYTE_GET (external->p_type);
4452       internal->p_offset = BYTE_GET (external->p_offset);
4453       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4454       internal->p_paddr  = BYTE_GET (external->p_paddr);
4455       internal->p_filesz = BYTE_GET (external->p_filesz);
4456       internal->p_memsz  = BYTE_GET (external->p_memsz);
4457       internal->p_flags  = BYTE_GET (external->p_flags);
4458       internal->p_align  = BYTE_GET (external->p_align);
4459     }
4460
4461   free (phdrs);
4462   return TRUE;
4463 }
4464
4465 static bfd_boolean
4466 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4467 {
4468   Elf64_External_Phdr * phdrs;
4469   Elf64_External_Phdr * external;
4470   Elf_Internal_Phdr *   internal;
4471   unsigned int i;
4472   unsigned int size = elf_header.e_phentsize;
4473   unsigned int num  = elf_header.e_phnum;
4474
4475   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4476   if (size == 0 || num == 0)
4477     return FALSE;
4478   if (size < sizeof * phdrs)
4479     {
4480       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4481       return FALSE;
4482     }
4483   if (size > sizeof * phdrs)
4484     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4485
4486   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4487                                             size, num, _("program headers"));
4488   if (!phdrs)
4489     return FALSE;
4490
4491   for (i = 0, internal = pheaders, external = phdrs;
4492        i < elf_header.e_phnum;
4493        i++, internal++, external++)
4494     {
4495       internal->p_type   = BYTE_GET (external->p_type);
4496       internal->p_flags  = BYTE_GET (external->p_flags);
4497       internal->p_offset = BYTE_GET (external->p_offset);
4498       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4499       internal->p_paddr  = BYTE_GET (external->p_paddr);
4500       internal->p_filesz = BYTE_GET (external->p_filesz);
4501       internal->p_memsz  = BYTE_GET (external->p_memsz);
4502       internal->p_align  = BYTE_GET (external->p_align);
4503     }
4504
4505   free (phdrs);
4506   return TRUE;
4507 }
4508
4509 /* Returns 1 if the program headers were read into `program_headers'.  */
4510
4511 static int
4512 get_program_headers (FILE * file)
4513 {
4514   Elf_Internal_Phdr * phdrs;
4515
4516   /* Check cache of prior read.  */
4517   if (program_headers != NULL)
4518     return 1;
4519
4520   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4521                                          sizeof (Elf_Internal_Phdr));
4522
4523   if (phdrs == NULL)
4524     {
4525       error (_("Out of memory reading %u program headers\n"),
4526              elf_header.e_phnum);
4527       return 0;
4528     }
4529
4530   if (is_32bit_elf
4531       ? get_32bit_program_headers (file, phdrs)
4532       : get_64bit_program_headers (file, phdrs))
4533     {
4534       program_headers = phdrs;
4535       return 1;
4536     }
4537
4538   free (phdrs);
4539   return 0;
4540 }
4541
4542 /* Returns 1 if the program headers were loaded.  */
4543
4544 static int
4545 process_program_headers (FILE * file)
4546 {
4547   Elf_Internal_Phdr * segment;
4548   unsigned int i;
4549
4550   if (elf_header.e_phnum == 0)
4551     {
4552       /* PR binutils/12467.  */
4553       if (elf_header.e_phoff != 0)
4554         warn (_("possibly corrupt ELF header - it has a non-zero program"
4555                 " header offset, but no program headers\n"));
4556       else if (do_segments)
4557         printf (_("\nThere are no program headers in this file.\n"));
4558       return 0;
4559     }
4560
4561   if (do_segments && !do_header)
4562     {
4563       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4564       printf (_("Entry point "));
4565       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4566       printf (_("\nThere are %d program headers, starting at offset "),
4567               elf_header.e_phnum);
4568       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4569       printf ("\n");
4570     }
4571
4572   if (! get_program_headers (file))
4573       return 0;
4574
4575   if (do_segments)
4576     {
4577       if (elf_header.e_phnum > 1)
4578         printf (_("\nProgram Headers:\n"));
4579       else
4580         printf (_("\nProgram Headers:\n"));
4581
4582       if (is_32bit_elf)
4583         printf
4584           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4585       else if (do_wide)
4586         printf
4587           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4588       else
4589         {
4590           printf
4591             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4592           printf
4593             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4594         }
4595     }
4596
4597   dynamic_addr = 0;
4598   dynamic_size = 0;
4599
4600   for (i = 0, segment = program_headers;
4601        i < elf_header.e_phnum;
4602        i++, segment++)
4603     {
4604       if (do_segments)
4605         {
4606           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4607
4608           if (is_32bit_elf)
4609             {
4610               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4611               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4612               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4613               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4614               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4615               printf ("%c%c%c ",
4616                       (segment->p_flags & PF_R ? 'R' : ' '),
4617                       (segment->p_flags & PF_W ? 'W' : ' '),
4618                       (segment->p_flags & PF_X ? 'E' : ' '));
4619               printf ("%#lx", (unsigned long) segment->p_align);
4620             }
4621           else if (do_wide)
4622             {
4623               if ((unsigned long) segment->p_offset == segment->p_offset)
4624                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4625               else
4626                 {
4627                   print_vma (segment->p_offset, FULL_HEX);
4628                   putchar (' ');
4629                 }
4630
4631               print_vma (segment->p_vaddr, FULL_HEX);
4632               putchar (' ');
4633               print_vma (segment->p_paddr, FULL_HEX);
4634               putchar (' ');
4635
4636               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4637                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4638               else
4639                 {
4640                   print_vma (segment->p_filesz, FULL_HEX);
4641                   putchar (' ');
4642                 }
4643
4644               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4645                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4646               else
4647                 {
4648                   print_vma (segment->p_memsz, FULL_HEX);
4649                 }
4650
4651               printf (" %c%c%c ",
4652                       (segment->p_flags & PF_R ? 'R' : ' '),
4653                       (segment->p_flags & PF_W ? 'W' : ' '),
4654                       (segment->p_flags & PF_X ? 'E' : ' '));
4655
4656               if ((unsigned long) segment->p_align == segment->p_align)
4657                 printf ("%#lx", (unsigned long) segment->p_align);
4658               else
4659                 {
4660                   print_vma (segment->p_align, PREFIX_HEX);
4661                 }
4662             }
4663           else
4664             {
4665               print_vma (segment->p_offset, FULL_HEX);
4666               putchar (' ');
4667               print_vma (segment->p_vaddr, FULL_HEX);
4668               putchar (' ');
4669               print_vma (segment->p_paddr, FULL_HEX);
4670               printf ("\n                 ");
4671               print_vma (segment->p_filesz, FULL_HEX);
4672               putchar (' ');
4673               print_vma (segment->p_memsz, FULL_HEX);
4674               printf ("  %c%c%c    ",
4675                       (segment->p_flags & PF_R ? 'R' : ' '),
4676                       (segment->p_flags & PF_W ? 'W' : ' '),
4677                       (segment->p_flags & PF_X ? 'E' : ' '));
4678               print_vma (segment->p_align, HEX);
4679             }
4680         }
4681
4682       if (do_segments)
4683         putc ('\n', stdout);
4684
4685       switch (segment->p_type)
4686         {
4687         case PT_DYNAMIC:
4688           if (dynamic_addr)
4689             error (_("more than one dynamic segment\n"));
4690
4691           /* By default, assume that the .dynamic section is the first
4692              section in the DYNAMIC segment.  */
4693           dynamic_addr = segment->p_offset;
4694           dynamic_size = segment->p_filesz;
4695           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4696           if (dynamic_addr + dynamic_size >= current_file_size)
4697             {
4698               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4699               dynamic_addr = dynamic_size = 0;
4700             }
4701
4702           /* Try to locate the .dynamic section. If there is
4703              a section header table, we can easily locate it.  */
4704           if (section_headers != NULL)
4705             {
4706               Elf_Internal_Shdr * sec;
4707
4708               sec = find_section (".dynamic");
4709               if (sec == NULL || sec->sh_size == 0)
4710                 {
4711                   /* A corresponding .dynamic section is expected, but on
4712                      IA-64/OpenVMS it is OK for it to be missing.  */
4713                   if (!is_ia64_vms ())
4714                     error (_("no .dynamic section in the dynamic segment\n"));
4715                   break;
4716                 }
4717
4718               if (sec->sh_type == SHT_NOBITS)
4719                 {
4720                   dynamic_size = 0;
4721                   break;
4722                 }
4723
4724               dynamic_addr = sec->sh_offset;
4725               dynamic_size = sec->sh_size;
4726
4727               if (dynamic_addr < segment->p_offset
4728                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4729                 warn (_("the .dynamic section is not contained"
4730                         " within the dynamic segment\n"));
4731               else if (dynamic_addr > segment->p_offset)
4732                 warn (_("the .dynamic section is not the first section"
4733                         " in the dynamic segment.\n"));
4734             }
4735           break;
4736
4737         case PT_INTERP:
4738           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4739                      SEEK_SET))
4740             error (_("Unable to find program interpreter name\n"));
4741           else
4742             {
4743               char fmt [32];
4744               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4745
4746               if (ret >= (int) sizeof (fmt) || ret < 0)
4747                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4748
4749               program_interpreter[0] = 0;
4750               if (fscanf (file, fmt, program_interpreter) <= 0)
4751                 error (_("Unable to read program interpreter name\n"));
4752
4753               if (do_segments)
4754                 printf (_("      [Requesting program interpreter: %s]\n"),
4755                     program_interpreter);
4756             }
4757           break;
4758         }
4759     }
4760
4761   if (do_segments && section_headers != NULL && string_table != NULL)
4762     {
4763       printf (_("\n Section to Segment mapping:\n"));
4764       printf (_("  Segment Sections...\n"));
4765
4766       for (i = 0; i < elf_header.e_phnum; i++)
4767         {
4768           unsigned int j;
4769           Elf_Internal_Shdr * section;
4770
4771           segment = program_headers + i;
4772           section = section_headers + 1;
4773
4774           printf ("   %2.2d     ", i);
4775
4776           for (j = 1; j < elf_header.e_shnum; j++, section++)
4777             {
4778               if (!ELF_TBSS_SPECIAL (section, segment)
4779                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4780                 printf ("%s ", printable_section_name (section));
4781             }
4782
4783           putc ('\n',stdout);
4784         }
4785     }
4786
4787   return 1;
4788 }
4789
4790
4791 /* Find the file offset corresponding to VMA by using the program headers.  */
4792
4793 static long
4794 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4795 {
4796   Elf_Internal_Phdr * seg;
4797
4798   if (! get_program_headers (file))
4799     {
4800       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4801       return (long) vma;
4802     }
4803
4804   for (seg = program_headers;
4805        seg < program_headers + elf_header.e_phnum;
4806        ++seg)
4807     {
4808       if (seg->p_type != PT_LOAD)
4809         continue;
4810
4811       if (vma >= (seg->p_vaddr & -seg->p_align)
4812           && vma + size <= seg->p_vaddr + seg->p_filesz)
4813         return vma - seg->p_vaddr + seg->p_offset;
4814     }
4815
4816   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4817         (unsigned long) vma);
4818   return (long) vma;
4819 }
4820
4821
4822 /* Allocate memory and load the sections headers into the global pointer
4823    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4824    generate any error messages if the load fails.  */
4825
4826 static bfd_boolean
4827 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4828 {
4829   Elf32_External_Shdr * shdrs;
4830   Elf_Internal_Shdr *   internal;
4831   unsigned int i;
4832   unsigned int size = elf_header.e_shentsize;
4833   unsigned int num = probe ? 1 : elf_header.e_shnum;
4834
4835   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4836   if (size == 0 || num == 0)
4837     return FALSE;
4838   if (size < sizeof * shdrs)
4839     {
4840       if (! probe)
4841         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4842       return FALSE;
4843     }
4844   if (!probe && size > sizeof * shdrs)
4845     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4846
4847   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4848                                             size, num,
4849                                             probe ? NULL : _("section headers"));
4850   if (shdrs == NULL)
4851     return FALSE;
4852
4853   if (section_headers != NULL)
4854     free (section_headers);
4855   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4856                                                    sizeof (Elf_Internal_Shdr));
4857   if (section_headers == NULL)
4858     {
4859       if (!probe)
4860         error (_("Out of memory reading %u section headers\n"), num);
4861       return FALSE;
4862     }
4863
4864   for (i = 0, internal = section_headers;
4865        i < num;
4866        i++, internal++)
4867     {
4868       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4869       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4870       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4871       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4872       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4873       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4874       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4875       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4876       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4877       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4878     }
4879
4880   free (shdrs);
4881   return TRUE;
4882 }
4883
4884 static bfd_boolean
4885 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4886 {
4887   Elf64_External_Shdr * shdrs;
4888   Elf_Internal_Shdr *   internal;
4889   unsigned int i;
4890   unsigned int size = elf_header.e_shentsize;
4891   unsigned int num = probe ? 1 : elf_header.e_shnum;
4892
4893   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4894   if (size == 0 || num == 0)
4895     return FALSE;
4896   if (size < sizeof * shdrs)
4897     {
4898       if (! probe)
4899         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4900       return FALSE;
4901     }
4902   if (! probe && size > sizeof * shdrs)
4903     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4904
4905   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4906                                             size, num,
4907                                             probe ? NULL : _("section headers"));
4908   if (shdrs == NULL)
4909     return FALSE;
4910
4911   if (section_headers != NULL)
4912     free (section_headers);
4913   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4914                                                    sizeof (Elf_Internal_Shdr));
4915   if (section_headers == NULL)
4916     {
4917       if (! probe)
4918         error (_("Out of memory reading %u section headers\n"), num);
4919       return FALSE;
4920     }
4921
4922   for (i = 0, internal = section_headers;
4923        i < num;
4924        i++, internal++)
4925     {
4926       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4927       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4928       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4929       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4930       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4931       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4932       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4933       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4934       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4935       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4936     }
4937
4938   free (shdrs);
4939   return TRUE;
4940 }
4941
4942 static Elf_Internal_Sym *
4943 get_32bit_elf_symbols (FILE * file,
4944                        Elf_Internal_Shdr * section,
4945                        unsigned long * num_syms_return)
4946 {
4947   unsigned long number = 0;
4948   Elf32_External_Sym * esyms = NULL;
4949   Elf_External_Sym_Shndx * shndx = NULL;
4950   Elf_Internal_Sym * isyms = NULL;
4951   Elf_Internal_Sym * psym;
4952   unsigned int j;
4953
4954   if (section->sh_size == 0)
4955     {
4956       if (num_syms_return != NULL)
4957         * num_syms_return = 0;
4958       return NULL;
4959     }
4960
4961   /* Run some sanity checks first.  */
4962   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4963     {
4964       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4965              printable_section_name (section), (unsigned long) section->sh_entsize);
4966       goto exit_point;
4967     }
4968
4969   if (section->sh_size > current_file_size)
4970     {
4971       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4972              printable_section_name (section), (unsigned long) section->sh_size);
4973       goto exit_point;
4974     }
4975
4976   number = section->sh_size / section->sh_entsize;
4977
4978   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4979     {
4980       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4981              (unsigned long) section->sh_size,
4982              printable_section_name (section),
4983              (unsigned long) section->sh_entsize);
4984       goto exit_point;
4985     }
4986
4987   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4988                                            section->sh_size, _("symbols"));
4989   if (esyms == NULL)
4990     goto exit_point;
4991
4992   shndx = NULL;
4993   if (symtab_shndx_hdr != NULL
4994       && (symtab_shndx_hdr->sh_link
4995           == (unsigned long) (section - section_headers)))
4996     {
4997       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4998                                                    symtab_shndx_hdr->sh_offset,
4999                                                    1, symtab_shndx_hdr->sh_size,
5000                                                    _("symbol table section indicies"));
5001       if (shndx == NULL)
5002         goto exit_point;
5003       /* PR17531: file: heap-buffer-overflow */
5004       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5005         {
5006           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5007                  printable_section_name (symtab_shndx_hdr),
5008                  (unsigned long) symtab_shndx_hdr->sh_size,
5009                  (unsigned long) section->sh_size);
5010           goto exit_point;
5011         }
5012     }
5013
5014   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5015
5016   if (isyms == NULL)
5017     {
5018       error (_("Out of memory reading %lu symbols\n"),
5019              (unsigned long) number);
5020       goto exit_point;
5021     }
5022
5023   for (j = 0, psym = isyms; j < number; j++, psym++)
5024     {
5025       psym->st_name  = BYTE_GET (esyms[j].st_name);
5026       psym->st_value = BYTE_GET (esyms[j].st_value);
5027       psym->st_size  = BYTE_GET (esyms[j].st_size);
5028       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5029       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5030         psym->st_shndx
5031           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5032       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5033         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5034       psym->st_info  = BYTE_GET (esyms[j].st_info);
5035       psym->st_other = BYTE_GET (esyms[j].st_other);
5036     }
5037
5038  exit_point:
5039   if (shndx != NULL)
5040     free (shndx);
5041   if (esyms != NULL)
5042     free (esyms);
5043
5044   if (num_syms_return != NULL)
5045     * num_syms_return = isyms == NULL ? 0 : number;
5046
5047   return isyms;
5048 }
5049
5050 static Elf_Internal_Sym *
5051 get_64bit_elf_symbols (FILE * file,
5052                        Elf_Internal_Shdr * section,
5053                        unsigned long * num_syms_return)
5054 {
5055   unsigned long number = 0;
5056   Elf64_External_Sym * esyms = NULL;
5057   Elf_External_Sym_Shndx * shndx = NULL;
5058   Elf_Internal_Sym * isyms = NULL;
5059   Elf_Internal_Sym * psym;
5060   unsigned int j;
5061
5062   if (section->sh_size == 0)
5063     {
5064       if (num_syms_return != NULL)
5065         * num_syms_return = 0;
5066       return NULL;
5067     }
5068
5069   /* Run some sanity checks first.  */
5070   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5071     {
5072       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5073              printable_section_name (section),
5074              (unsigned long) section->sh_entsize);
5075       goto exit_point;
5076     }
5077
5078   if (section->sh_size > current_file_size)
5079     {
5080       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5081              printable_section_name (section),
5082              (unsigned long) section->sh_size);
5083       goto exit_point;
5084     }
5085
5086   number = section->sh_size / section->sh_entsize;
5087
5088   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5089     {
5090       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5091              (unsigned long) section->sh_size,
5092              printable_section_name (section),
5093              (unsigned long) section->sh_entsize);
5094       goto exit_point;
5095     }
5096
5097   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5098                                            section->sh_size, _("symbols"));
5099   if (!esyms)
5100     goto exit_point;
5101
5102   if (symtab_shndx_hdr != NULL
5103       && (symtab_shndx_hdr->sh_link
5104           == (unsigned long) (section - section_headers)))
5105     {
5106       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5107                                                    symtab_shndx_hdr->sh_offset,
5108                                                    1, symtab_shndx_hdr->sh_size,
5109                                                    _("symbol table section indicies"));
5110       if (shndx == NULL)
5111         goto exit_point;
5112       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5113         {
5114           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5115                  printable_section_name (symtab_shndx_hdr),
5116                  (unsigned long) symtab_shndx_hdr->sh_size,
5117                  (unsigned long) section->sh_size);
5118           goto exit_point;
5119         }
5120     }
5121
5122   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5123
5124   if (isyms == NULL)
5125     {
5126       error (_("Out of memory reading %lu symbols\n"),
5127              (unsigned long) number);
5128       goto exit_point;
5129     }
5130
5131   for (j = 0, psym = isyms; j < number; j++, psym++)
5132     {
5133       psym->st_name  = BYTE_GET (esyms[j].st_name);
5134       psym->st_info  = BYTE_GET (esyms[j].st_info);
5135       psym->st_other = BYTE_GET (esyms[j].st_other);
5136       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5137
5138       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5139         psym->st_shndx
5140           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5141       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5142         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5143
5144       psym->st_value = BYTE_GET (esyms[j].st_value);
5145       psym->st_size  = BYTE_GET (esyms[j].st_size);
5146     }
5147
5148  exit_point:
5149   if (shndx != NULL)
5150     free (shndx);
5151   if (esyms != NULL)
5152     free (esyms);
5153
5154   if (num_syms_return != NULL)
5155     * num_syms_return = isyms == NULL ? 0 : number;
5156
5157   return isyms;
5158 }
5159
5160 static const char *
5161 get_elf_section_flags (bfd_vma sh_flags)
5162 {
5163   static char buff[1024];
5164   char * p = buff;
5165   int field_size = is_32bit_elf ? 8 : 16;
5166   int sindex;
5167   int size = sizeof (buff) - (field_size + 4 + 1);
5168   bfd_vma os_flags = 0;
5169   bfd_vma proc_flags = 0;
5170   bfd_vma unknown_flags = 0;
5171   static const struct
5172     {
5173       const char * str;
5174       int len;
5175     }
5176   flags [] =
5177     {
5178       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5179       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5180       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5181       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5182       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5183       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5184       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5185       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5186       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5187       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5188       /* IA-64 specific.  */
5189       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5190       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5191       /* IA-64 OpenVMS specific.  */
5192       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5193       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5194       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5195       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5196       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5197       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5198       /* Generic.  */
5199       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5200       /* SPARC specific.  */
5201       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5202       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5203     };
5204
5205   if (do_section_details)
5206     {
5207       sprintf (buff, "[%*.*lx]: ",
5208                field_size, field_size, (unsigned long) sh_flags);
5209       p += field_size + 4;
5210     }
5211
5212   while (sh_flags)
5213     {
5214       bfd_vma flag;
5215
5216       flag = sh_flags & - sh_flags;
5217       sh_flags &= ~ flag;
5218
5219       if (do_section_details)
5220         {
5221           switch (flag)
5222             {
5223             case SHF_WRITE:             sindex = 0; break;
5224             case SHF_ALLOC:             sindex = 1; break;
5225             case SHF_EXECINSTR:         sindex = 2; break;
5226             case SHF_MERGE:             sindex = 3; break;
5227             case SHF_STRINGS:           sindex = 4; break;
5228             case SHF_INFO_LINK:         sindex = 5; break;
5229             case SHF_LINK_ORDER:        sindex = 6; break;
5230             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5231             case SHF_GROUP:             sindex = 8; break;
5232             case SHF_TLS:               sindex = 9; break;
5233             case SHF_EXCLUDE:           sindex = 18; break;
5234             case SHF_COMPRESSED:        sindex = 20; break;
5235
5236             default:
5237               sindex = -1;
5238               switch (elf_header.e_machine)
5239                 {
5240                 case EM_IA_64:
5241                   if (flag == SHF_IA_64_SHORT)
5242                     sindex = 10;
5243                   else if (flag == SHF_IA_64_NORECOV)
5244                     sindex = 11;
5245 #ifdef BFD64
5246                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5247                     switch (flag)
5248                       {
5249                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5250                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5251                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5252                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5253                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5254                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5255                       default:                        break;
5256                       }
5257 #endif
5258                   break;
5259
5260                 case EM_386:
5261                 case EM_IAMCU:
5262                 case EM_X86_64:
5263                 case EM_L1OM:
5264                 case EM_K1OM:
5265                 case EM_OLD_SPARCV9:
5266                 case EM_SPARC32PLUS:
5267                 case EM_SPARCV9:
5268                 case EM_SPARC:
5269                   if (flag == SHF_ORDERED)
5270                     sindex = 19;
5271                   break;
5272                 default:
5273                   break;
5274                 }
5275             }
5276
5277           if (sindex != -1)
5278             {
5279               if (p != buff + field_size + 4)
5280                 {
5281                   if (size < (10 + 2))
5282                     {
5283                       warn (_("Internal error: not enough buffer room for section flag info"));
5284                       return _("<unknown>");
5285                     }
5286                   size -= 2;
5287                   *p++ = ',';
5288                   *p++ = ' ';
5289                 }
5290
5291               size -= flags [sindex].len;
5292               p = stpcpy (p, flags [sindex].str);
5293             }
5294           else if (flag & SHF_MASKOS)
5295             os_flags |= flag;
5296           else if (flag & SHF_MASKPROC)
5297             proc_flags |= flag;
5298           else
5299             unknown_flags |= flag;
5300         }
5301       else
5302         {
5303           switch (flag)
5304             {
5305             case SHF_WRITE:             *p = 'W'; break;
5306             case SHF_ALLOC:             *p = 'A'; break;
5307             case SHF_EXECINSTR:         *p = 'X'; break;
5308             case SHF_MERGE:             *p = 'M'; break;
5309             case SHF_STRINGS:           *p = 'S'; break;
5310             case SHF_INFO_LINK:         *p = 'I'; break;
5311             case SHF_LINK_ORDER:        *p = 'L'; break;
5312             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5313             case SHF_GROUP:             *p = 'G'; break;
5314             case SHF_TLS:               *p = 'T'; break;
5315             case SHF_EXCLUDE:           *p = 'E'; break;
5316             case SHF_COMPRESSED:        *p = 'C'; break;
5317
5318             default:
5319               if ((elf_header.e_machine == EM_X86_64
5320                    || elf_header.e_machine == EM_L1OM
5321                    || elf_header.e_machine == EM_K1OM)
5322                   && flag == SHF_X86_64_LARGE)
5323                 *p = 'l';
5324               else if (flag & SHF_MASKOS)
5325                 {
5326                   *p = 'o';
5327                   sh_flags &= ~ SHF_MASKOS;
5328                 }
5329               else if (flag & SHF_MASKPROC)
5330                 {
5331                   *p = 'p';
5332                   sh_flags &= ~ SHF_MASKPROC;
5333                 }
5334               else
5335                 *p = 'x';
5336               break;
5337             }
5338           p++;
5339         }
5340     }
5341
5342   if (do_section_details)
5343     {
5344       if (os_flags)
5345         {
5346           size -= 5 + field_size;
5347           if (p != buff + field_size + 4)
5348             {
5349               if (size < (2 + 1))
5350                 {
5351                   warn (_("Internal error: not enough buffer room for section flag info"));
5352                   return _("<unknown>");
5353                 }
5354               size -= 2;
5355               *p++ = ',';
5356               *p++ = ' ';
5357             }
5358           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5359                    (unsigned long) os_flags);
5360           p += 5 + field_size;
5361         }
5362       if (proc_flags)
5363         {
5364           size -= 7 + field_size;
5365           if (p != buff + field_size + 4)
5366             {
5367               if (size < (2 + 1))
5368                 {
5369                   warn (_("Internal error: not enough buffer room for section flag info"));
5370                   return _("<unknown>");
5371                 }
5372               size -= 2;
5373               *p++ = ',';
5374               *p++ = ' ';
5375             }
5376           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5377                    (unsigned long) proc_flags);
5378           p += 7 + field_size;
5379         }
5380       if (unknown_flags)
5381         {
5382           size -= 10 + field_size;
5383           if (p != buff + field_size + 4)
5384             {
5385               if (size < (2 + 1))
5386                 {
5387                   warn (_("Internal error: not enough buffer room for section flag info"));
5388                   return _("<unknown>");
5389                 }
5390               size -= 2;
5391               *p++ = ',';
5392               *p++ = ' ';
5393             }
5394           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5395                    (unsigned long) unknown_flags);
5396           p += 10 + field_size;
5397         }
5398     }
5399
5400   *p = '\0';
5401   return buff;
5402 }
5403
5404 static unsigned int
5405 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5406 {
5407   if (is_32bit_elf)
5408     {
5409       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5410       chdr->ch_type = BYTE_GET (echdr->ch_type);
5411       chdr->ch_size = BYTE_GET (echdr->ch_size);
5412       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5413       return sizeof (*echdr);
5414     }
5415   else
5416     {
5417       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5418       chdr->ch_type = BYTE_GET (echdr->ch_type);
5419       chdr->ch_size = BYTE_GET (echdr->ch_size);
5420       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5421       return sizeof (*echdr);
5422     }
5423 }
5424
5425 static int
5426 process_section_headers (FILE * file)
5427 {
5428   Elf_Internal_Shdr * section;
5429   unsigned int i;
5430
5431   section_headers = NULL;
5432
5433   if (elf_header.e_shnum == 0)
5434     {
5435       /* PR binutils/12467.  */
5436       if (elf_header.e_shoff != 0)
5437         warn (_("possibly corrupt ELF file header - it has a non-zero"
5438                 " section header offset, but no section headers\n"));
5439       else if (do_sections)
5440         printf (_("\nThere are no sections in this file.\n"));
5441
5442       return 1;
5443     }
5444
5445   if (do_sections && !do_header)
5446     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5447             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5448
5449   if (is_32bit_elf)
5450     {
5451       if (! get_32bit_section_headers (file, FALSE))
5452         return 0;
5453     }
5454   else if (! get_64bit_section_headers (file, FALSE))
5455     return 0;
5456
5457   /* Read in the string table, so that we have names to display.  */
5458   if (elf_header.e_shstrndx != SHN_UNDEF
5459        && elf_header.e_shstrndx < elf_header.e_shnum)
5460     {
5461       section = section_headers + elf_header.e_shstrndx;
5462
5463       if (section->sh_size != 0)
5464         {
5465           string_table = (char *) get_data (NULL, file, section->sh_offset,
5466                                             1, section->sh_size,
5467                                             _("string table"));
5468
5469           string_table_length = string_table != NULL ? section->sh_size : 0;
5470         }
5471     }
5472
5473   /* Scan the sections for the dynamic symbol table
5474      and dynamic string table and debug sections.  */
5475   dynamic_symbols = NULL;
5476   dynamic_strings = NULL;
5477   dynamic_syminfo = NULL;
5478   symtab_shndx_hdr = NULL;
5479
5480   eh_addr_size = is_32bit_elf ? 4 : 8;
5481   switch (elf_header.e_machine)
5482     {
5483     case EM_MIPS:
5484     case EM_MIPS_RS3_LE:
5485       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5486          FDE addresses.  However, the ABI also has a semi-official ILP32
5487          variant for which the normal FDE address size rules apply.
5488
5489          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5490          section, where XX is the size of longs in bits.  Unfortunately,
5491          earlier compilers provided no way of distinguishing ILP32 objects
5492          from LP64 objects, so if there's any doubt, we should assume that
5493          the official LP64 form is being used.  */
5494       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5495           && find_section (".gcc_compiled_long32") == NULL)
5496         eh_addr_size = 8;
5497       break;
5498
5499     case EM_H8_300:
5500     case EM_H8_300H:
5501       switch (elf_header.e_flags & EF_H8_MACH)
5502         {
5503         case E_H8_MACH_H8300:
5504         case E_H8_MACH_H8300HN:
5505         case E_H8_MACH_H8300SN:
5506         case E_H8_MACH_H8300SXN:
5507           eh_addr_size = 2;
5508           break;
5509         case E_H8_MACH_H8300H:
5510         case E_H8_MACH_H8300S:
5511         case E_H8_MACH_H8300SX:
5512           eh_addr_size = 4;
5513           break;
5514         }
5515       break;
5516
5517     case EM_M32C_OLD:
5518     case EM_M32C:
5519       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5520         {
5521         case EF_M32C_CPU_M16C:
5522           eh_addr_size = 2;
5523           break;
5524         }
5525       break;
5526     }
5527
5528 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5529   do                                                                    \
5530     {                                                                   \
5531       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5532       if (section->sh_entsize != expected_entsize)                      \
5533         {                                                               \
5534           char buf[40];                                                 \
5535           sprintf_vma (buf, section->sh_entsize);                       \
5536           /* Note: coded this way so that there is a single string for  \
5537              translation.  */ \
5538           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5539           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5540                    (unsigned) expected_entsize);                        \
5541           section->sh_entsize = expected_entsize;                       \
5542         }                                                               \
5543     }                                                                   \
5544   while (0)
5545
5546 #define CHECK_ENTSIZE(section, i, type)                                 \
5547   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5548                         sizeof (Elf64_External_##type))
5549
5550   for (i = 0, section = section_headers;
5551        i < elf_header.e_shnum;
5552        i++, section++)
5553     {
5554       char * name = SECTION_NAME (section);
5555
5556       if (section->sh_type == SHT_DYNSYM)
5557         {
5558           if (dynamic_symbols != NULL)
5559             {
5560               error (_("File contains multiple dynamic symbol tables\n"));
5561               continue;
5562             }
5563
5564           CHECK_ENTSIZE (section, i, Sym);
5565           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5566         }
5567       else if (section->sh_type == SHT_STRTAB
5568                && streq (name, ".dynstr"))
5569         {
5570           if (dynamic_strings != NULL)
5571             {
5572               error (_("File contains multiple dynamic string tables\n"));
5573               continue;
5574             }
5575
5576           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5577                                                1, section->sh_size,
5578                                                _("dynamic strings"));
5579           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5580         }
5581       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5582         {
5583           if (symtab_shndx_hdr != NULL)
5584             {
5585               error (_("File contains multiple symtab shndx tables\n"));
5586               continue;
5587             }
5588           symtab_shndx_hdr = section;
5589         }
5590       else if (section->sh_type == SHT_SYMTAB)
5591         CHECK_ENTSIZE (section, i, Sym);
5592       else if (section->sh_type == SHT_GROUP)
5593         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5594       else if (section->sh_type == SHT_REL)
5595         CHECK_ENTSIZE (section, i, Rel);
5596       else if (section->sh_type == SHT_RELA)
5597         CHECK_ENTSIZE (section, i, Rela);
5598       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5599                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5600                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5601                 || do_debug_str || do_debug_loc || do_debug_ranges
5602                 || do_debug_addr || do_debug_cu_index)
5603                && (const_strneq (name, ".debug_")
5604                    || const_strneq (name, ".zdebug_")))
5605         {
5606           if (name[1] == 'z')
5607             name += sizeof (".zdebug_") - 1;
5608           else
5609             name += sizeof (".debug_") - 1;
5610
5611           if (do_debugging
5612               || (do_debug_info     && const_strneq (name, "info"))
5613               || (do_debug_info     && const_strneq (name, "types"))
5614               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5615               || (do_debug_lines    && strcmp (name, "line") == 0)
5616               || (do_debug_lines    && const_strneq (name, "line."))
5617               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5618               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5619               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5620               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5621               || (do_debug_aranges  && const_strneq (name, "aranges"))
5622               || (do_debug_ranges   && const_strneq (name, "ranges"))
5623               || (do_debug_frames   && const_strneq (name, "frame"))
5624               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5625               || (do_debug_macinfo  && const_strneq (name, "macro"))
5626               || (do_debug_str      && const_strneq (name, "str"))
5627               || (do_debug_loc      && const_strneq (name, "loc"))
5628               || (do_debug_addr     && const_strneq (name, "addr"))
5629               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5630               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5631               )
5632             request_dump_bynumber (i, DEBUG_DUMP);
5633         }
5634       /* Linkonce section to be combined with .debug_info at link time.  */
5635       else if ((do_debugging || do_debug_info)
5636                && const_strneq (name, ".gnu.linkonce.wi."))
5637         request_dump_bynumber (i, DEBUG_DUMP);
5638       else if (do_debug_frames && streq (name, ".eh_frame"))
5639         request_dump_bynumber (i, DEBUG_DUMP);
5640       else if (do_gdb_index && streq (name, ".gdb_index"))
5641         request_dump_bynumber (i, DEBUG_DUMP);
5642       /* Trace sections for Itanium VMS.  */
5643       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5644                 || do_trace_aranges)
5645                && const_strneq (name, ".trace_"))
5646         {
5647           name += sizeof (".trace_") - 1;
5648
5649           if (do_debugging
5650               || (do_trace_info     && streq (name, "info"))
5651               || (do_trace_abbrevs  && streq (name, "abbrev"))
5652               || (do_trace_aranges  && streq (name, "aranges"))
5653               )
5654             request_dump_bynumber (i, DEBUG_DUMP);
5655         }
5656     }
5657
5658   if (! do_sections)
5659     return 1;
5660
5661   if (elf_header.e_shnum > 1)
5662     printf (_("\nSection Headers:\n"));
5663   else
5664     printf (_("\nSection Header:\n"));
5665
5666   if (is_32bit_elf)
5667     {
5668       if (do_section_details)
5669         {
5670           printf (_("  [Nr] Name\n"));
5671           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5672         }
5673       else
5674         printf
5675           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5676     }
5677   else if (do_wide)
5678     {
5679       if (do_section_details)
5680         {
5681           printf (_("  [Nr] Name\n"));
5682           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5683         }
5684       else
5685         printf
5686           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5687     }
5688   else
5689     {
5690       if (do_section_details)
5691         {
5692           printf (_("  [Nr] Name\n"));
5693           printf (_("       Type              Address          Offset            Link\n"));
5694           printf (_("       Size              EntSize          Info              Align\n"));
5695         }
5696       else
5697         {
5698           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5699           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5700         }
5701     }
5702
5703   if (do_section_details)
5704     printf (_("       Flags\n"));
5705
5706   for (i = 0, section = section_headers;
5707        i < elf_header.e_shnum;
5708        i++, section++)
5709     {
5710       printf ("  [%2u] ", i);
5711       if (do_section_details)
5712         printf ("%s\n      ", printable_section_name (section));
5713       else
5714         print_symbol (-17, SECTION_NAME (section));
5715
5716       printf (do_wide ? " %-15s " : " %-15.15s ",
5717               get_section_type_name (section->sh_type));
5718
5719       if (is_32bit_elf)
5720         {
5721           const char * link_too_big = NULL;
5722
5723           print_vma (section->sh_addr, LONG_HEX);
5724
5725           printf ( " %6.6lx %6.6lx %2.2lx",
5726                    (unsigned long) section->sh_offset,
5727                    (unsigned long) section->sh_size,
5728                    (unsigned long) section->sh_entsize);
5729
5730           if (do_section_details)
5731             fputs ("  ", stdout);
5732           else
5733             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5734
5735           if (section->sh_link >= elf_header.e_shnum)
5736             {
5737               link_too_big = "";
5738               /* The sh_link value is out of range.  Normally this indicates
5739                  an error but it can have special values in Solaris binaries.  */
5740               switch (elf_header.e_machine)
5741                 {
5742                 case EM_386:
5743                 case EM_IAMCU:
5744                 case EM_X86_64:
5745                 case EM_L1OM:
5746                 case EM_K1OM:
5747                 case EM_OLD_SPARCV9:
5748                 case EM_SPARC32PLUS:
5749                 case EM_SPARCV9:
5750                 case EM_SPARC:
5751                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5752                     link_too_big = "BEFORE";
5753                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5754                     link_too_big = "AFTER";
5755                   break;
5756                 default:
5757                   break;
5758                 }
5759             }
5760
5761           if (do_section_details)
5762             {
5763               if (link_too_big != NULL && * link_too_big)
5764                 printf ("<%s> ", link_too_big);
5765               else
5766                 printf ("%2u ", section->sh_link);
5767               printf ("%3u %2lu\n", section->sh_info,
5768                       (unsigned long) section->sh_addralign);
5769             }
5770           else
5771             printf ("%2u %3u %2lu\n",
5772                     section->sh_link,
5773                     section->sh_info,
5774                     (unsigned long) section->sh_addralign);
5775
5776           if (link_too_big && ! * link_too_big)
5777             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5778                   i, section->sh_link);
5779         }
5780       else if (do_wide)
5781         {
5782           print_vma (section->sh_addr, LONG_HEX);
5783
5784           if ((long) section->sh_offset == section->sh_offset)
5785             printf (" %6.6lx", (unsigned long) section->sh_offset);
5786           else
5787             {
5788               putchar (' ');
5789               print_vma (section->sh_offset, LONG_HEX);
5790             }
5791
5792           if ((unsigned long) section->sh_size == section->sh_size)
5793             printf (" %6.6lx", (unsigned long) section->sh_size);
5794           else
5795             {
5796               putchar (' ');
5797               print_vma (section->sh_size, LONG_HEX);
5798             }
5799
5800           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5801             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5802           else
5803             {
5804               putchar (' ');
5805               print_vma (section->sh_entsize, LONG_HEX);
5806             }
5807
5808           if (do_section_details)
5809             fputs ("  ", stdout);
5810           else
5811             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5812
5813           printf ("%2u %3u ", section->sh_link, section->sh_info);
5814
5815           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5816             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5817           else
5818             {
5819               print_vma (section->sh_addralign, DEC);
5820               putchar ('\n');
5821             }
5822         }
5823       else if (do_section_details)
5824         {
5825           printf ("       %-15.15s  ",
5826                   get_section_type_name (section->sh_type));
5827           print_vma (section->sh_addr, LONG_HEX);
5828           if ((long) section->sh_offset == section->sh_offset)
5829             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5830           else
5831             {
5832               printf ("  ");
5833               print_vma (section->sh_offset, LONG_HEX);
5834             }
5835           printf ("  %u\n       ", section->sh_link);
5836           print_vma (section->sh_size, LONG_HEX);
5837           putchar (' ');
5838           print_vma (section->sh_entsize, LONG_HEX);
5839
5840           printf ("  %-16u  %lu\n",
5841                   section->sh_info,
5842                   (unsigned long) section->sh_addralign);
5843         }
5844       else
5845         {
5846           putchar (' ');
5847           print_vma (section->sh_addr, LONG_HEX);
5848           if ((long) section->sh_offset == section->sh_offset)
5849             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5850           else
5851             {
5852               printf ("  ");
5853               print_vma (section->sh_offset, LONG_HEX);
5854             }
5855           printf ("\n       ");
5856           print_vma (section->sh_size, LONG_HEX);
5857           printf ("  ");
5858           print_vma (section->sh_entsize, LONG_HEX);
5859
5860           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5861
5862           printf ("     %2u   %3u     %lu\n",
5863                   section->sh_link,
5864                   section->sh_info,
5865                   (unsigned long) section->sh_addralign);
5866         }
5867
5868       if (do_section_details)
5869         {
5870           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5871           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5872             {
5873               /* Minimum section size is 12 bytes for 32-bit compression
5874                  header + 12 bytes for compressed data header.  */
5875               unsigned char buf[24];
5876               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5877               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5878                             sizeof (buf), _("compression header")))
5879                 {
5880                   Elf_Internal_Chdr chdr;
5881                   get_compression_header (&chdr, buf);
5882                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5883                     printf ("       ZLIB, ");
5884                   else
5885                     printf (_("       [<unknown>: 0x%x], "),
5886                             chdr.ch_type);
5887                   print_vma (chdr.ch_size, LONG_HEX);
5888                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5889                 }
5890             }
5891         }
5892     }
5893
5894   if (!do_section_details)
5895     {
5896       if (elf_header.e_machine == EM_X86_64
5897           || elf_header.e_machine == EM_L1OM
5898           || elf_header.e_machine == EM_K1OM)
5899         printf (_("Key to Flags:\n\
5900   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5901   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5902   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5903       else
5904         printf (_("Key to Flags:\n\
5905   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5906   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5907   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5908     }
5909
5910   return 1;
5911 }
5912
5913 static const char *
5914 get_group_flags (unsigned int flags)
5915 {
5916   static char buff[32];
5917   switch (flags)
5918     {
5919     case 0:
5920       return "";
5921
5922     case GRP_COMDAT:
5923       return "COMDAT ";
5924
5925    default:
5926       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5927       break;
5928     }
5929   return buff;
5930 }
5931
5932 static int
5933 process_section_groups (FILE * file)
5934 {
5935   Elf_Internal_Shdr * section;
5936   unsigned int i;
5937   struct group * group;
5938   Elf_Internal_Shdr * symtab_sec;
5939   Elf_Internal_Shdr * strtab_sec;
5940   Elf_Internal_Sym * symtab;
5941   unsigned long num_syms;
5942   char * strtab;
5943   size_t strtab_size;
5944
5945   /* Don't process section groups unless needed.  */
5946   if (!do_unwind && !do_section_groups)
5947     return 1;
5948
5949   if (elf_header.e_shnum == 0)
5950     {
5951       if (do_section_groups)
5952         printf (_("\nThere are no sections to group in this file.\n"));
5953
5954       return 1;
5955     }
5956
5957   if (section_headers == NULL)
5958     {
5959       error (_("Section headers are not available!\n"));
5960       /* PR 13622: This can happen with a corrupt ELF header.  */
5961       return 0;
5962     }
5963
5964   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5965                                                      sizeof (struct group *));
5966
5967   if (section_headers_groups == NULL)
5968     {
5969       error (_("Out of memory reading %u section group headers\n"),
5970              elf_header.e_shnum);
5971       return 0;
5972     }
5973
5974   /* Scan the sections for the group section.  */
5975   group_count = 0;
5976   for (i = 0, section = section_headers;
5977        i < elf_header.e_shnum;
5978        i++, section++)
5979     if (section->sh_type == SHT_GROUP)
5980       group_count++;
5981
5982   if (group_count == 0)
5983     {
5984       if (do_section_groups)
5985         printf (_("\nThere are no section groups in this file.\n"));
5986
5987       return 1;
5988     }
5989
5990   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5991
5992   if (section_groups == NULL)
5993     {
5994       error (_("Out of memory reading %lu groups\n"),
5995              (unsigned long) group_count);
5996       return 0;
5997     }
5998
5999   symtab_sec = NULL;
6000   strtab_sec = NULL;
6001   symtab = NULL;
6002   num_syms = 0;
6003   strtab = NULL;
6004   strtab_size = 0;
6005   for (i = 0, section = section_headers, group = section_groups;
6006        i < elf_header.e_shnum;
6007        i++, section++)
6008     {
6009       if (section->sh_type == SHT_GROUP)
6010         {
6011           const char * name = printable_section_name (section);
6012           const char * group_name;
6013           unsigned char * start;
6014           unsigned char * indices;
6015           unsigned int entry, j, size;
6016           Elf_Internal_Shdr * sec;
6017           Elf_Internal_Sym * sym;
6018
6019           /* Get the symbol table.  */
6020           if (section->sh_link >= elf_header.e_shnum
6021               || ((sec = section_headers + section->sh_link)->sh_type
6022                   != SHT_SYMTAB))
6023             {
6024               error (_("Bad sh_link in group section `%s'\n"), name);
6025               continue;
6026             }
6027
6028           if (symtab_sec != sec)
6029             {
6030               symtab_sec = sec;
6031               if (symtab)
6032                 free (symtab);
6033               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6034             }
6035
6036           if (symtab == NULL)
6037             {
6038               error (_("Corrupt header in group section `%s'\n"), name);
6039               continue;
6040             }
6041
6042           if (section->sh_info >= num_syms)
6043             {
6044               error (_("Bad sh_info in group section `%s'\n"), name);
6045               continue;
6046             }
6047
6048           sym = symtab + section->sh_info;
6049
6050           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6051             {
6052               if (sym->st_shndx == 0
6053                   || sym->st_shndx >= elf_header.e_shnum)
6054                 {
6055                   error (_("Bad sh_info in group section `%s'\n"), name);
6056                   continue;
6057                 }
6058
6059               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6060               strtab_sec = NULL;
6061               if (strtab)
6062                 free (strtab);
6063               strtab = NULL;
6064               strtab_size = 0;
6065             }
6066           else
6067             {
6068               /* Get the string table.  */
6069               if (symtab_sec->sh_link >= elf_header.e_shnum)
6070                 {
6071                   strtab_sec = NULL;
6072                   if (strtab)
6073                     free (strtab);
6074                   strtab = NULL;
6075                   strtab_size = 0;
6076                 }
6077               else if (strtab_sec
6078                        != (sec = section_headers + symtab_sec->sh_link))
6079                 {
6080                   strtab_sec = sec;
6081                   if (strtab)
6082                     free (strtab);
6083
6084                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6085                                               1, strtab_sec->sh_size,
6086                                               _("string table"));
6087                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6088                 }
6089               group_name = sym->st_name < strtab_size
6090                 ? strtab + sym->st_name : _("<corrupt>");
6091             }
6092
6093           /* PR 17531: file: loop.  */
6094           if (section->sh_entsize > section->sh_size)
6095             {
6096               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6097                      printable_section_name (section),
6098                      (unsigned long) section->sh_entsize,
6099                      (unsigned long) section->sh_size);
6100               break;
6101             }
6102
6103           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6104                                               1, section->sh_size,
6105                                               _("section data"));
6106           if (start == NULL)
6107             continue;
6108
6109           indices = start;
6110           size = (section->sh_size / section->sh_entsize) - 1;
6111           entry = byte_get (indices, 4);
6112           indices += 4;
6113
6114           if (do_section_groups)
6115             {
6116               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6117                       get_group_flags (entry), i, name, group_name, size);
6118
6119               printf (_("   [Index]    Name\n"));
6120             }
6121
6122           group->group_index = i;
6123
6124           for (j = 0; j < size; j++)
6125             {
6126               struct group_list * g;
6127
6128               entry = byte_get (indices, 4);
6129               indices += 4;
6130
6131               if (entry >= elf_header.e_shnum)
6132                 {
6133                   static unsigned num_group_errors = 0;
6134
6135                   if (num_group_errors ++ < 10)
6136                     {
6137                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6138                              entry, i, elf_header.e_shnum - 1);
6139                       if (num_group_errors == 10)
6140                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6141                     }
6142                   continue;
6143                 }
6144
6145               if (section_headers_groups [entry] != NULL)
6146                 {
6147                   if (entry)
6148                     {
6149                       static unsigned num_errs = 0;
6150
6151                       if (num_errs ++ < 10)
6152                         {
6153                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6154                                  entry, i,
6155                                  section_headers_groups [entry]->group_index);
6156                           if (num_errs == 10)
6157                             warn (_("Further error messages about already contained group sections suppressed\n"));
6158                         }
6159                       continue;
6160                     }
6161                   else
6162                     {
6163                       /* Intel C/C++ compiler may put section 0 in a
6164                          section group. We just warn it the first time
6165                          and ignore it afterwards.  */
6166                       static int warned = 0;
6167                       if (!warned)
6168                         {
6169                           error (_("section 0 in group section [%5u]\n"),
6170                                  section_headers_groups [entry]->group_index);
6171                           warned++;
6172                         }
6173                     }
6174                 }
6175
6176               section_headers_groups [entry] = group;
6177
6178               if (do_section_groups)
6179                 {
6180                   sec = section_headers + entry;
6181                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6182                 }
6183
6184               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6185               g->section_index = entry;
6186               g->next = group->root;
6187               group->root = g;
6188             }
6189
6190           if (start)
6191             free (start);
6192
6193           group++;
6194         }
6195     }
6196
6197   if (symtab)
6198     free (symtab);
6199   if (strtab)
6200     free (strtab);
6201   return 1;
6202 }
6203
6204 /* Data used to display dynamic fixups.  */
6205
6206 struct ia64_vms_dynfixup
6207 {
6208   bfd_vma needed_ident;         /* Library ident number.  */
6209   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6210   bfd_vma fixup_needed;         /* Index of the library.  */
6211   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6212   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6213 };
6214
6215 /* Data used to display dynamic relocations.  */
6216
6217 struct ia64_vms_dynimgrela
6218 {
6219   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6220   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6221 };
6222
6223 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6224    library).  */
6225
6226 static void
6227 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6228                               const char *strtab, unsigned int strtab_sz)
6229 {
6230   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6231   long i;
6232   const char *lib_name;
6233
6234   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6235                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6236                    _("dynamic section image fixups"));
6237   if (!imfs)
6238     return;
6239
6240   if (fixup->needed < strtab_sz)
6241     lib_name = strtab + fixup->needed;
6242   else
6243     {
6244       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6245             (unsigned long) fixup->needed);
6246       lib_name = "???";
6247     }
6248   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6249           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6250   printf
6251     (_("Seg Offset           Type                             SymVec DataType\n"));
6252
6253   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6254     {
6255       unsigned int type;
6256       const char *rtype;
6257
6258       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6259       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6260       type = BYTE_GET (imfs [i].type);
6261       rtype = elf_ia64_reloc_type (type);
6262       if (rtype == NULL)
6263         printf (" 0x%08x                       ", type);
6264       else
6265         printf (" %-32s ", rtype);
6266       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6267       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6268     }
6269
6270   free (imfs);
6271 }
6272
6273 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6274
6275 static void
6276 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6277 {
6278   Elf64_External_VMS_IMAGE_RELA *imrs;
6279   long i;
6280
6281   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6282                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6283                    _("dynamic section image relocations"));
6284   if (!imrs)
6285     return;
6286
6287   printf (_("\nImage relocs\n"));
6288   printf
6289     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6290
6291   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6292     {
6293       unsigned int type;
6294       const char *rtype;
6295
6296       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6297       printf ("%08" BFD_VMA_FMT "x ",
6298               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6299       type = BYTE_GET (imrs [i].type);
6300       rtype = elf_ia64_reloc_type (type);
6301       if (rtype == NULL)
6302         printf ("0x%08x                      ", type);
6303       else
6304         printf ("%-31s ", rtype);
6305       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6306       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6307       printf ("%08" BFD_VMA_FMT "x\n",
6308               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6309     }
6310
6311   free (imrs);
6312 }
6313
6314 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6315
6316 static int
6317 process_ia64_vms_dynamic_relocs (FILE *file)
6318 {
6319   struct ia64_vms_dynfixup fixup;
6320   struct ia64_vms_dynimgrela imgrela;
6321   Elf_Internal_Dyn *entry;
6322   int res = 0;
6323   bfd_vma strtab_off = 0;
6324   bfd_vma strtab_sz = 0;
6325   char *strtab = NULL;
6326
6327   memset (&fixup, 0, sizeof (fixup));
6328   memset (&imgrela, 0, sizeof (imgrela));
6329
6330   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6331   for (entry = dynamic_section;
6332        entry < dynamic_section + dynamic_nent;
6333        entry++)
6334     {
6335       switch (entry->d_tag)
6336         {
6337         case DT_IA_64_VMS_STRTAB_OFFSET:
6338           strtab_off = entry->d_un.d_val;
6339           break;
6340         case DT_STRSZ:
6341           strtab_sz = entry->d_un.d_val;
6342           if (strtab == NULL)
6343             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6344                                1, strtab_sz, _("dynamic string section"));
6345           break;
6346
6347         case DT_IA_64_VMS_NEEDED_IDENT:
6348           fixup.needed_ident = entry->d_un.d_val;
6349           break;
6350         case DT_NEEDED:
6351           fixup.needed = entry->d_un.d_val;
6352           break;
6353         case DT_IA_64_VMS_FIXUP_NEEDED:
6354           fixup.fixup_needed = entry->d_un.d_val;
6355           break;
6356         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6357           fixup.fixup_rela_cnt = entry->d_un.d_val;
6358           break;
6359         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6360           fixup.fixup_rela_off = entry->d_un.d_val;
6361           res++;
6362           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6363           break;
6364
6365         case DT_IA_64_VMS_IMG_RELA_CNT:
6366           imgrela.img_rela_cnt = entry->d_un.d_val;
6367           break;
6368         case DT_IA_64_VMS_IMG_RELA_OFF:
6369           imgrela.img_rela_off = entry->d_un.d_val;
6370           res++;
6371           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6372           break;
6373
6374         default:
6375           break;
6376         }
6377     }
6378
6379   if (strtab != NULL)
6380     free (strtab);
6381
6382   return res;
6383 }
6384
6385 static struct
6386 {
6387   const char * name;
6388   int reloc;
6389   int size;
6390   int rela;
6391 } dynamic_relocations [] =
6392 {
6393     { "REL", DT_REL, DT_RELSZ, FALSE },
6394     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6395     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6396 };
6397
6398 /* Process the reloc section.  */
6399
6400 static int
6401 process_relocs (FILE * file)
6402 {
6403   unsigned long rel_size;
6404   unsigned long rel_offset;
6405
6406
6407   if (!do_reloc)
6408     return 1;
6409
6410   if (do_using_dynamic)
6411     {
6412       int is_rela;
6413       const char * name;
6414       int has_dynamic_reloc;
6415       unsigned int i;
6416
6417       has_dynamic_reloc = 0;
6418
6419       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6420         {
6421           is_rela = dynamic_relocations [i].rela;
6422           name = dynamic_relocations [i].name;
6423           rel_size = dynamic_info [dynamic_relocations [i].size];
6424           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6425
6426           has_dynamic_reloc |= rel_size;
6427
6428           if (is_rela == UNKNOWN)
6429             {
6430               if (dynamic_relocations [i].reloc == DT_JMPREL)
6431                 switch (dynamic_info[DT_PLTREL])
6432                   {
6433                   case DT_REL:
6434                     is_rela = FALSE;
6435                     break;
6436                   case DT_RELA:
6437                     is_rela = TRUE;
6438                     break;
6439                   }
6440             }
6441
6442           if (rel_size)
6443             {
6444               printf
6445                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6446                  name, rel_offset, rel_size);
6447
6448               dump_relocations (file,
6449                                 offset_from_vma (file, rel_offset, rel_size),
6450                                 rel_size,
6451                                 dynamic_symbols, num_dynamic_syms,
6452                                 dynamic_strings, dynamic_strings_length,
6453                                 is_rela, 1);
6454             }
6455         }
6456
6457       if (is_ia64_vms ())
6458         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6459
6460       if (! has_dynamic_reloc)
6461         printf (_("\nThere are no dynamic relocations in this file.\n"));
6462     }
6463   else
6464     {
6465       Elf_Internal_Shdr * section;
6466       unsigned long i;
6467       int found = 0;
6468
6469       for (i = 0, section = section_headers;
6470            i < elf_header.e_shnum;
6471            i++, section++)
6472         {
6473           if (   section->sh_type != SHT_RELA
6474               && section->sh_type != SHT_REL)
6475             continue;
6476
6477           rel_offset = section->sh_offset;
6478           rel_size   = section->sh_size;
6479
6480           if (rel_size)
6481             {
6482               Elf_Internal_Shdr * strsec;
6483               int is_rela;
6484
6485               printf (_("\nRelocation section "));
6486
6487               if (string_table == NULL)
6488                 printf ("%d", section->sh_name);
6489               else
6490                 printf ("'%s'", printable_section_name (section));
6491
6492               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6493                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6494
6495               is_rela = section->sh_type == SHT_RELA;
6496
6497               if (section->sh_link != 0
6498                   && section->sh_link < elf_header.e_shnum)
6499                 {
6500                   Elf_Internal_Shdr * symsec;
6501                   Elf_Internal_Sym *  symtab;
6502                   unsigned long nsyms;
6503                   unsigned long strtablen = 0;
6504                   char * strtab = NULL;
6505
6506                   symsec = section_headers + section->sh_link;
6507                   if (symsec->sh_type != SHT_SYMTAB
6508                       && symsec->sh_type != SHT_DYNSYM)
6509                     continue;
6510
6511                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6512
6513                   if (symtab == NULL)
6514                     continue;
6515
6516                   if (symsec->sh_link != 0
6517                       && symsec->sh_link < elf_header.e_shnum)
6518                     {
6519                       strsec = section_headers + symsec->sh_link;
6520
6521                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6522                                                   1, strsec->sh_size,
6523                                                   _("string table"));
6524                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6525                     }
6526
6527                   dump_relocations (file, rel_offset, rel_size,
6528                                     symtab, nsyms, strtab, strtablen,
6529                                     is_rela,
6530                                     symsec->sh_type == SHT_DYNSYM);
6531                   if (strtab)
6532                     free (strtab);
6533                   free (symtab);
6534                 }
6535               else
6536                 dump_relocations (file, rel_offset, rel_size,
6537                                   NULL, 0, NULL, 0, is_rela, 0);
6538
6539               found = 1;
6540             }
6541         }
6542
6543       if (! found)
6544         printf (_("\nThere are no relocations in this file.\n"));
6545     }
6546
6547   return 1;
6548 }
6549
6550 /* An absolute address consists of a section and an offset.  If the
6551    section is NULL, the offset itself is the address, otherwise, the
6552    address equals to LOAD_ADDRESS(section) + offset.  */
6553
6554 struct absaddr
6555 {
6556   unsigned short section;
6557   bfd_vma offset;
6558 };
6559
6560 #define ABSADDR(a) \
6561   ((a).section \
6562    ? section_headers [(a).section].sh_addr + (a).offset \
6563    : (a).offset)
6564
6565 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6566    name, if found, and the offset from the symbol to ADDR.  */
6567
6568 static void
6569 find_symbol_for_address (Elf_Internal_Sym * symtab,
6570                          unsigned long      nsyms,
6571                          const char *       strtab,
6572                          unsigned long      strtab_size,
6573                          struct absaddr     addr,
6574                          const char **      symname,
6575                          bfd_vma *          offset)
6576 {
6577   bfd_vma dist = 0x100000;
6578   Elf_Internal_Sym * sym;
6579   Elf_Internal_Sym * beg;
6580   Elf_Internal_Sym * end;
6581   Elf_Internal_Sym * best = NULL;
6582
6583   REMOVE_ARCH_BITS (addr.offset);
6584   beg = symtab;
6585   end = symtab + nsyms;
6586
6587   while (beg < end)
6588     {
6589       bfd_vma value;
6590
6591       sym = beg + (end - beg) / 2;
6592
6593       value = sym->st_value;
6594       REMOVE_ARCH_BITS (value);
6595
6596       if (sym->st_name != 0
6597           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6598           && addr.offset >= value
6599           && addr.offset - value < dist)
6600         {
6601           best = sym;
6602           dist = addr.offset - value;
6603           if (!dist)
6604             break;
6605         }
6606
6607       if (addr.offset < value)
6608         end = sym;
6609       else
6610         beg = sym + 1;
6611     }
6612
6613   if (best)
6614     {
6615       *symname = (best->st_name >= strtab_size
6616                   ? _("<corrupt>") : strtab + best->st_name);
6617       *offset = dist;
6618       return;
6619     }
6620
6621   *symname = NULL;
6622   *offset = addr.offset;
6623 }
6624
6625 static int
6626 symcmp (const void *p, const void *q)
6627 {
6628   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6629   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6630
6631   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6632 }
6633
6634 /* Process the unwind section.  */
6635
6636 #include "unwind-ia64.h"
6637
6638 struct ia64_unw_table_entry
6639 {
6640   struct absaddr start;
6641   struct absaddr end;
6642   struct absaddr info;
6643 };
6644
6645 struct ia64_unw_aux_info
6646 {
6647   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6648   unsigned long table_len;              /* Length of unwind table.  */
6649   unsigned char * info;                 /* Unwind info.  */
6650   unsigned long info_size;              /* Size of unwind info.  */
6651   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6652   bfd_vma seg_base;                     /* Starting address of segment.  */
6653   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6654   unsigned long nsyms;                  /* Number of symbols.  */
6655   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6656   unsigned long nfuns;                  /* Number of entries in funtab.  */
6657   char * strtab;                        /* The string table.  */
6658   unsigned long strtab_size;            /* Size of string table.  */
6659 };
6660
6661 static void
6662 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6663 {
6664   struct ia64_unw_table_entry * tp;
6665   unsigned long j, nfuns;
6666   int in_body;
6667
6668   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6669   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6670     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6671       aux->funtab[nfuns++] = aux->symtab[j];
6672   aux->nfuns = nfuns;
6673   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6674
6675   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6676     {
6677       bfd_vma stamp;
6678       bfd_vma offset;
6679       const unsigned char * dp;
6680       const unsigned char * head;
6681       const unsigned char * end;
6682       const char * procname;
6683
6684       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6685                                aux->strtab_size, tp->start, &procname, &offset);
6686
6687       fputs ("\n<", stdout);
6688
6689       if (procname)
6690         {
6691           fputs (procname, stdout);
6692
6693           if (offset)
6694             printf ("+%lx", (unsigned long) offset);
6695         }
6696
6697       fputs (">: [", stdout);
6698       print_vma (tp->start.offset, PREFIX_HEX);
6699       fputc ('-', stdout);
6700       print_vma (tp->end.offset, PREFIX_HEX);
6701       printf ("], info at +0x%lx\n",
6702               (unsigned long) (tp->info.offset - aux->seg_base));
6703
6704       /* PR 17531: file: 86232b32.  */
6705       if (aux->info == NULL)
6706         continue;
6707
6708       /* PR 17531: file: 0997b4d1.  */
6709       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6710         {
6711           warn (_("Invalid offset %lx in table entry %ld\n"),
6712                 (long) tp->info.offset, (long) (tp - aux->table));
6713           continue;
6714         }
6715
6716       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6717       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6718
6719       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6720               (unsigned) UNW_VER (stamp),
6721               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6722               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6723               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6724               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6725
6726       if (UNW_VER (stamp) != 1)
6727         {
6728           printf (_("\tUnknown version.\n"));
6729           continue;
6730         }
6731
6732       in_body = 0;
6733       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6734       /* PR 17531: file: 16ceda89.  */
6735       if (end > aux->info + aux->info_size)
6736         end = aux->info + aux->info_size;
6737       for (dp = head + 8; dp < end;)
6738         dp = unw_decode (dp, in_body, & in_body);
6739     }
6740
6741   free (aux->funtab);
6742 }
6743
6744 static bfd_boolean
6745 slurp_ia64_unwind_table (FILE * file,
6746                          struct ia64_unw_aux_info * aux,
6747                          Elf_Internal_Shdr * sec)
6748 {
6749   unsigned long size, nrelas, i;
6750   Elf_Internal_Phdr * seg;
6751   struct ia64_unw_table_entry * tep;
6752   Elf_Internal_Shdr * relsec;
6753   Elf_Internal_Rela * rela;
6754   Elf_Internal_Rela * rp;
6755   unsigned char * table;
6756   unsigned char * tp;
6757   Elf_Internal_Sym * sym;
6758   const char * relname;
6759
6760   aux->table_len = 0;
6761
6762   /* First, find the starting address of the segment that includes
6763      this section: */
6764
6765   if (elf_header.e_phnum)
6766     {
6767       if (! get_program_headers (file))
6768           return FALSE;
6769
6770       for (seg = program_headers;
6771            seg < program_headers + elf_header.e_phnum;
6772            ++seg)
6773         {
6774           if (seg->p_type != PT_LOAD)
6775             continue;
6776
6777           if (sec->sh_addr >= seg->p_vaddr
6778               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6779             {
6780               aux->seg_base = seg->p_vaddr;
6781               break;
6782             }
6783         }
6784     }
6785
6786   /* Second, build the unwind table from the contents of the unwind section:  */
6787   size = sec->sh_size;
6788   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6789                                       _("unwind table"));
6790   if (!table)
6791     return FALSE;
6792
6793   aux->table_len = size / (3 * eh_addr_size);
6794   aux->table = (struct ia64_unw_table_entry *)
6795     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6796   tep = aux->table;
6797
6798   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6799     {
6800       tep->start.section = SHN_UNDEF;
6801       tep->end.section   = SHN_UNDEF;
6802       tep->info.section  = SHN_UNDEF;
6803       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6804       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6805       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6806       tep->start.offset += aux->seg_base;
6807       tep->end.offset   += aux->seg_base;
6808       tep->info.offset  += aux->seg_base;
6809     }
6810   free (table);
6811
6812   /* Third, apply any relocations to the unwind table:  */
6813   for (relsec = section_headers;
6814        relsec < section_headers + elf_header.e_shnum;
6815        ++relsec)
6816     {
6817       if (relsec->sh_type != SHT_RELA
6818           || relsec->sh_info >= elf_header.e_shnum
6819           || section_headers + relsec->sh_info != sec)
6820         continue;
6821
6822       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6823                               & rela, & nrelas))
6824         {
6825           free (aux->table);
6826           aux->table = NULL;
6827           aux->table_len = 0;
6828           return FALSE;
6829         }
6830
6831       for (rp = rela; rp < rela + nrelas; ++rp)
6832         {
6833           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6834           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6835
6836           /* PR 17531: file: 9fa67536.  */
6837           if (relname == NULL)
6838             {
6839               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6840               continue;
6841             }
6842
6843           if (! const_strneq (relname, "R_IA64_SEGREL"))
6844             {
6845               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6846               continue;
6847             }
6848
6849           i = rp->r_offset / (3 * eh_addr_size);
6850
6851           /* PR 17531: file: 5bc8d9bf.  */
6852           if (i >= aux->table_len)
6853             {
6854               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6855               continue;
6856             }
6857
6858           switch (rp->r_offset / eh_addr_size % 3)
6859             {
6860             case 0:
6861               aux->table[i].start.section = sym->st_shndx;
6862               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6863               break;
6864             case 1:
6865               aux->table[i].end.section   = sym->st_shndx;
6866               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6867               break;
6868             case 2:
6869               aux->table[i].info.section  = sym->st_shndx;
6870               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6871               break;
6872             default:
6873               break;
6874             }
6875         }
6876
6877       free (rela);
6878     }
6879
6880   return TRUE;
6881 }
6882
6883 static void
6884 ia64_process_unwind (FILE * file)
6885 {
6886   Elf_Internal_Shdr * sec;
6887   Elf_Internal_Shdr * unwsec = NULL;
6888   Elf_Internal_Shdr * strsec;
6889   unsigned long i, unwcount = 0, unwstart = 0;
6890   struct ia64_unw_aux_info aux;
6891
6892   memset (& aux, 0, sizeof (aux));
6893
6894   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6895     {
6896       if (sec->sh_type == SHT_SYMTAB
6897           && sec->sh_link < elf_header.e_shnum)
6898         {
6899           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6900
6901           strsec = section_headers + sec->sh_link;
6902           if (aux.strtab != NULL)
6903             {
6904               error (_("Multiple auxillary string tables encountered\n"));
6905               free (aux.strtab);
6906             }
6907           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6908                                           1, strsec->sh_size,
6909                                           _("string table"));
6910           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6911         }
6912       else if (sec->sh_type == SHT_IA_64_UNWIND)
6913         unwcount++;
6914     }
6915
6916   if (!unwcount)
6917     printf (_("\nThere are no unwind sections in this file.\n"));
6918
6919   while (unwcount-- > 0)
6920     {
6921       char * suffix;
6922       size_t len, len2;
6923
6924       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6925            i < elf_header.e_shnum; ++i, ++sec)
6926         if (sec->sh_type == SHT_IA_64_UNWIND)
6927           {
6928             unwsec = sec;
6929             break;
6930           }
6931       /* We have already counted the number of SHT_IA64_UNWIND
6932          sections so the loop above should never fail.  */
6933       assert (unwsec != NULL);
6934
6935       unwstart = i + 1;
6936       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6937
6938       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6939         {
6940           /* We need to find which section group it is in.  */
6941           struct group_list * g;
6942
6943           if (section_headers_groups == NULL
6944               || section_headers_groups [i] == NULL)
6945             i = elf_header.e_shnum;
6946           else
6947             {
6948               g = section_headers_groups [i]->root;
6949
6950               for (; g != NULL; g = g->next)
6951                 {
6952                   sec = section_headers + g->section_index;
6953
6954                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6955                     break;
6956                 }
6957
6958               if (g == NULL)
6959                 i = elf_header.e_shnum;
6960             }
6961         }
6962       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6963         {
6964           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6965           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6966           suffix = SECTION_NAME (unwsec) + len;
6967           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6968                ++i, ++sec)
6969             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6970                 && streq (SECTION_NAME (sec) + len2, suffix))
6971               break;
6972         }
6973       else
6974         {
6975           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6976              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6977           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6978           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6979           suffix = "";
6980           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6981             suffix = SECTION_NAME (unwsec) + len;
6982           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6983                ++i, ++sec)
6984             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6985                 && streq (SECTION_NAME (sec) + len2, suffix))
6986               break;
6987         }
6988
6989       if (i == elf_header.e_shnum)
6990         {
6991           printf (_("\nCould not find unwind info section for "));
6992
6993           if (string_table == NULL)
6994             printf ("%d", unwsec->sh_name);
6995           else
6996             printf ("'%s'", printable_section_name (unwsec));
6997         }
6998       else
6999         {
7000           aux.info_addr = sec->sh_addr;
7001           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7002                                                  sec->sh_size,
7003                                                  _("unwind info"));
7004           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7005
7006           printf (_("\nUnwind section "));
7007
7008           if (string_table == NULL)
7009             printf ("%d", unwsec->sh_name);
7010           else
7011             printf ("'%s'", printable_section_name (unwsec));
7012
7013           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7014                   (unsigned long) unwsec->sh_offset,
7015                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7016
7017           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7018               && aux.table_len > 0)
7019             dump_ia64_unwind (& aux);
7020
7021           if (aux.table)
7022             free ((char *) aux.table);
7023           if (aux.info)
7024             free ((char *) aux.info);
7025           aux.table = NULL;
7026           aux.info = NULL;
7027         }
7028     }
7029
7030   if (aux.symtab)
7031     free (aux.symtab);
7032   if (aux.strtab)
7033     free ((char *) aux.strtab);
7034 }
7035
7036 struct hppa_unw_table_entry
7037   {
7038     struct absaddr start;
7039     struct absaddr end;
7040     unsigned int Cannot_unwind:1;               /* 0 */
7041     unsigned int Millicode:1;                   /* 1 */
7042     unsigned int Millicode_save_sr0:1;          /* 2 */
7043     unsigned int Region_description:2;          /* 3..4 */
7044     unsigned int reserved1:1;                   /* 5 */
7045     unsigned int Entry_SR:1;                    /* 6 */
7046     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7047     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7048     unsigned int Args_stored:1;                 /* 16 */
7049     unsigned int Variable_Frame:1;              /* 17 */
7050     unsigned int Separate_Package_Body:1;       /* 18 */
7051     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7052     unsigned int Stack_Overflow_Check:1;        /* 20 */
7053     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7054     unsigned int Ada_Region:1;                  /* 22 */
7055     unsigned int cxx_info:1;                    /* 23 */
7056     unsigned int cxx_try_catch:1;               /* 24 */
7057     unsigned int sched_entry_seq:1;             /* 25 */
7058     unsigned int reserved2:1;                   /* 26 */
7059     unsigned int Save_SP:1;                     /* 27 */
7060     unsigned int Save_RP:1;                     /* 28 */
7061     unsigned int Save_MRP_in_frame:1;           /* 29 */
7062     unsigned int extn_ptr_defined:1;            /* 30 */
7063     unsigned int Cleanup_defined:1;             /* 31 */
7064
7065     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7066     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7067     unsigned int Large_frame:1;                 /* 2 */
7068     unsigned int Pseudo_SP_Set:1;               /* 3 */
7069     unsigned int reserved4:1;                   /* 4 */
7070     unsigned int Total_frame_size:27;           /* 5..31 */
7071   };
7072
7073 struct hppa_unw_aux_info
7074 {
7075   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7076   unsigned long table_len;              /* Length of unwind table.  */
7077   bfd_vma seg_base;                     /* Starting address of segment.  */
7078   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7079   unsigned long nsyms;                  /* Number of symbols.  */
7080   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7081   unsigned long nfuns;                  /* Number of entries in funtab.  */
7082   char * strtab;                        /* The string table.  */
7083   unsigned long strtab_size;            /* Size of string table.  */
7084 };
7085
7086 static void
7087 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7088 {
7089   struct hppa_unw_table_entry * tp;
7090   unsigned long j, nfuns;
7091
7092   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7093   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7094     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7095       aux->funtab[nfuns++] = aux->symtab[j];
7096   aux->nfuns = nfuns;
7097   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7098
7099   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7100     {
7101       bfd_vma offset;
7102       const char * procname;
7103
7104       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7105                                aux->strtab_size, tp->start, &procname,
7106                                &offset);
7107
7108       fputs ("\n<", stdout);
7109
7110       if (procname)
7111         {
7112           fputs (procname, stdout);
7113
7114           if (offset)
7115             printf ("+%lx", (unsigned long) offset);
7116         }
7117
7118       fputs (">: [", stdout);
7119       print_vma (tp->start.offset, PREFIX_HEX);
7120       fputc ('-', stdout);
7121       print_vma (tp->end.offset, PREFIX_HEX);
7122       printf ("]\n\t");
7123
7124 #define PF(_m) if (tp->_m) printf (#_m " ");
7125 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7126       PF(Cannot_unwind);
7127       PF(Millicode);
7128       PF(Millicode_save_sr0);
7129       /* PV(Region_description);  */
7130       PF(Entry_SR);
7131       PV(Entry_FR);
7132       PV(Entry_GR);
7133       PF(Args_stored);
7134       PF(Variable_Frame);
7135       PF(Separate_Package_Body);
7136       PF(Frame_Extension_Millicode);
7137       PF(Stack_Overflow_Check);
7138       PF(Two_Instruction_SP_Increment);
7139       PF(Ada_Region);
7140       PF(cxx_info);
7141       PF(cxx_try_catch);
7142       PF(sched_entry_seq);
7143       PF(Save_SP);
7144       PF(Save_RP);
7145       PF(Save_MRP_in_frame);
7146       PF(extn_ptr_defined);
7147       PF(Cleanup_defined);
7148       PF(MPE_XL_interrupt_marker);
7149       PF(HP_UX_interrupt_marker);
7150       PF(Large_frame);
7151       PF(Pseudo_SP_Set);
7152       PV(Total_frame_size);
7153 #undef PF
7154 #undef PV
7155     }
7156
7157   printf ("\n");
7158
7159   free (aux->funtab);
7160 }
7161
7162 static int
7163 slurp_hppa_unwind_table (FILE * file,
7164                          struct hppa_unw_aux_info * aux,
7165                          Elf_Internal_Shdr * sec)
7166 {
7167   unsigned long size, unw_ent_size, nentries, nrelas, i;
7168   Elf_Internal_Phdr * seg;
7169   struct hppa_unw_table_entry * tep;
7170   Elf_Internal_Shdr * relsec;
7171   Elf_Internal_Rela * rela;
7172   Elf_Internal_Rela * rp;
7173   unsigned char * table;
7174   unsigned char * tp;
7175   Elf_Internal_Sym * sym;
7176   const char * relname;
7177
7178   /* First, find the starting address of the segment that includes
7179      this section.  */
7180
7181   if (elf_header.e_phnum)
7182     {
7183       if (! get_program_headers (file))
7184         return 0;
7185
7186       for (seg = program_headers;
7187            seg < program_headers + elf_header.e_phnum;
7188            ++seg)
7189         {
7190           if (seg->p_type != PT_LOAD)
7191             continue;
7192
7193           if (sec->sh_addr >= seg->p_vaddr
7194               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7195             {
7196               aux->seg_base = seg->p_vaddr;
7197               break;
7198             }
7199         }
7200     }
7201
7202   /* Second, build the unwind table from the contents of the unwind
7203      section.  */
7204   size = sec->sh_size;
7205   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7206                                       _("unwind table"));
7207   if (!table)
7208     return 0;
7209
7210   unw_ent_size = 16;
7211   nentries = size / unw_ent_size;
7212   size = unw_ent_size * nentries;
7213
7214   tep = aux->table = (struct hppa_unw_table_entry *)
7215       xcmalloc (nentries, sizeof (aux->table[0]));
7216
7217   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7218     {
7219       unsigned int tmp1, tmp2;
7220
7221       tep->start.section = SHN_UNDEF;
7222       tep->end.section   = SHN_UNDEF;
7223
7224       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7225       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7226       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7227       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7228
7229       tep->start.offset += aux->seg_base;
7230       tep->end.offset   += aux->seg_base;
7231
7232       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7233       tep->Millicode = (tmp1 >> 30) & 0x1;
7234       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7235       tep->Region_description = (tmp1 >> 27) & 0x3;
7236       tep->reserved1 = (tmp1 >> 26) & 0x1;
7237       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7238       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7239       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7240       tep->Args_stored = (tmp1 >> 15) & 0x1;
7241       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7242       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7243       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7244       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7245       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7246       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7247       tep->cxx_info = (tmp1 >> 8) & 0x1;
7248       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7249       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7250       tep->reserved2 = (tmp1 >> 5) & 0x1;
7251       tep->Save_SP = (tmp1 >> 4) & 0x1;
7252       tep->Save_RP = (tmp1 >> 3) & 0x1;
7253       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7254       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7255       tep->Cleanup_defined = tmp1 & 0x1;
7256
7257       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7258       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7259       tep->Large_frame = (tmp2 >> 29) & 0x1;
7260       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7261       tep->reserved4 = (tmp2 >> 27) & 0x1;
7262       tep->Total_frame_size = tmp2 & 0x7ffffff;
7263     }
7264   free (table);
7265
7266   /* Third, apply any relocations to the unwind table.  */
7267   for (relsec = section_headers;
7268        relsec < section_headers + elf_header.e_shnum;
7269        ++relsec)
7270     {
7271       if (relsec->sh_type != SHT_RELA
7272           || relsec->sh_info >= elf_header.e_shnum
7273           || section_headers + relsec->sh_info != sec)
7274         continue;
7275
7276       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7277                               & rela, & nrelas))
7278         return 0;
7279
7280       for (rp = rela; rp < rela + nrelas; ++rp)
7281         {
7282           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7283           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7284
7285           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7286           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7287             {
7288               warn (_("Skipping unexpected relocation type %s\n"), relname);
7289               continue;
7290             }
7291
7292           i = rp->r_offset / unw_ent_size;
7293
7294           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7295             {
7296             case 0:
7297               aux->table[i].start.section = sym->st_shndx;
7298               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7299               break;
7300             case 1:
7301               aux->table[i].end.section   = sym->st_shndx;
7302               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7303               break;
7304             default:
7305               break;
7306             }
7307         }
7308
7309       free (rela);
7310     }
7311
7312   aux->table_len = nentries;
7313
7314   return 1;
7315 }
7316
7317 static void
7318 hppa_process_unwind (FILE * file)
7319 {
7320   struct hppa_unw_aux_info aux;
7321   Elf_Internal_Shdr * unwsec = NULL;
7322   Elf_Internal_Shdr * strsec;
7323   Elf_Internal_Shdr * sec;
7324   unsigned long i;
7325
7326   if (string_table == NULL)
7327     return;
7328
7329   memset (& aux, 0, sizeof (aux));
7330
7331   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7332     {
7333       if (sec->sh_type == SHT_SYMTAB
7334           && sec->sh_link < elf_header.e_shnum)
7335         {
7336           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7337
7338           strsec = section_headers + sec->sh_link;
7339           if (aux.strtab != NULL)
7340             {
7341               error (_("Multiple auxillary string tables encountered\n"));
7342               free (aux.strtab);
7343             }
7344           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7345                                           1, strsec->sh_size,
7346                                           _("string table"));
7347           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7348         }
7349       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7350         unwsec = sec;
7351     }
7352
7353   if (!unwsec)
7354     printf (_("\nThere are no unwind sections in this file.\n"));
7355
7356   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7357     {
7358       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7359         {
7360           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7361                   printable_section_name (sec),
7362                   (unsigned long) sec->sh_offset,
7363                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7364
7365           slurp_hppa_unwind_table (file, &aux, sec);
7366           if (aux.table_len > 0)
7367             dump_hppa_unwind (&aux);
7368
7369           if (aux.table)
7370             free ((char *) aux.table);
7371           aux.table = NULL;
7372         }
7373     }
7374
7375   if (aux.symtab)
7376     free (aux.symtab);
7377   if (aux.strtab)
7378     free ((char *) aux.strtab);
7379 }
7380
7381 struct arm_section
7382 {
7383   unsigned char *      data;            /* The unwind data.  */
7384   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7385   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7386   unsigned long        nrelas;          /* The number of relocations.  */
7387   unsigned int         rel_type;        /* REL or RELA ?  */
7388   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7389 };
7390
7391 struct arm_unw_aux_info
7392 {
7393   FILE *              file;             /* The file containing the unwind sections.  */
7394   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7395   unsigned long       nsyms;            /* Number of symbols.  */
7396   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7397   unsigned long       nfuns;            /* Number of these symbols.  */
7398   char *              strtab;           /* The file's string table.  */
7399   unsigned long       strtab_size;      /* Size of string table.  */
7400 };
7401
7402 static const char *
7403 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7404                         bfd_vma fn, struct absaddr addr)
7405 {
7406   const char *procname;
7407   bfd_vma sym_offset;
7408
7409   if (addr.section == SHN_UNDEF)
7410     addr.offset = fn;
7411
7412   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7413                            aux->strtab_size, addr, &procname,
7414                            &sym_offset);
7415
7416   print_vma (fn, PREFIX_HEX);
7417
7418   if (procname)
7419     {
7420       fputs (" <", stdout);
7421       fputs (procname, stdout);
7422
7423       if (sym_offset)
7424         printf ("+0x%lx", (unsigned long) sym_offset);
7425       fputc ('>', stdout);
7426     }
7427
7428   return procname;
7429 }
7430
7431 static void
7432 arm_free_section (struct arm_section *arm_sec)
7433 {
7434   if (arm_sec->data != NULL)
7435     free (arm_sec->data);
7436
7437   if (arm_sec->rela != NULL)
7438     free (arm_sec->rela);
7439 }
7440
7441 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7442       cached section and install SEC instead.
7443    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7444       and return its valued in * WORDP, relocating if necessary.
7445    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7446       relocation's offset in ADDR.
7447    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7448       into the string table of the symbol associated with the reloc.  If no
7449       reloc was applied store -1 there.
7450    5) Return TRUE upon success, FALSE otherwise.  */
7451
7452 static bfd_boolean
7453 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7454                          struct arm_section *       arm_sec,
7455                          Elf_Internal_Shdr *        sec,
7456                          bfd_vma                    word_offset,
7457                          unsigned int *             wordp,
7458                          struct absaddr *           addr,
7459                          bfd_vma *                  sym_name)
7460 {
7461   Elf_Internal_Rela *rp;
7462   Elf_Internal_Sym *sym;
7463   const char * relname;
7464   unsigned int word;
7465   bfd_boolean wrapped;
7466
7467   if (sec == NULL || arm_sec == NULL)
7468     return FALSE;
7469
7470   addr->section = SHN_UNDEF;
7471   addr->offset = 0;
7472
7473   if (sym_name != NULL)
7474     *sym_name = (bfd_vma) -1;
7475
7476   /* If necessary, update the section cache.  */
7477   if (sec != arm_sec->sec)
7478     {
7479       Elf_Internal_Shdr *relsec;
7480
7481       arm_free_section (arm_sec);
7482
7483       arm_sec->sec = sec;
7484       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7485                                 sec->sh_size, _("unwind data"));
7486       arm_sec->rela = NULL;
7487       arm_sec->nrelas = 0;
7488
7489       for (relsec = section_headers;
7490            relsec < section_headers + elf_header.e_shnum;
7491            ++relsec)
7492         {
7493           if (relsec->sh_info >= elf_header.e_shnum
7494               || section_headers + relsec->sh_info != sec
7495               /* PR 15745: Check the section type as well.  */
7496               || (relsec->sh_type != SHT_REL
7497                   && relsec->sh_type != SHT_RELA))
7498             continue;
7499
7500           arm_sec->rel_type = relsec->sh_type;
7501           if (relsec->sh_type == SHT_REL)
7502             {
7503               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7504                                      relsec->sh_size,
7505                                      & arm_sec->rela, & arm_sec->nrelas))
7506                 return FALSE;
7507             }
7508           else /* relsec->sh_type == SHT_RELA */
7509             {
7510               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7511                                       relsec->sh_size,
7512                                       & arm_sec->rela, & arm_sec->nrelas))
7513                 return FALSE;
7514             }
7515           break;
7516         }
7517
7518       arm_sec->next_rela = arm_sec->rela;
7519     }
7520
7521   /* If there is no unwind data we can do nothing.  */
7522   if (arm_sec->data == NULL)
7523     return FALSE;
7524
7525   /* If the offset is invalid then fail.  */
7526   if (word_offset > sec->sh_size - 4)
7527     return FALSE;
7528
7529   /* Get the word at the required offset.  */
7530   word = byte_get (arm_sec->data + word_offset, 4);
7531
7532   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7533   if (arm_sec->rela == NULL)
7534     {
7535       * wordp = word;
7536       return TRUE;
7537     }
7538
7539   /* Look through the relocs to find the one that applies to the provided offset.  */
7540   wrapped = FALSE;
7541   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7542     {
7543       bfd_vma prelval, offset;
7544
7545       if (rp->r_offset > word_offset && !wrapped)
7546         {
7547           rp = arm_sec->rela;
7548           wrapped = TRUE;
7549         }
7550       if (rp->r_offset > word_offset)
7551         break;
7552
7553       if (rp->r_offset & 3)
7554         {
7555           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7556                 (unsigned long) rp->r_offset);
7557           continue;
7558         }
7559
7560       if (rp->r_offset < word_offset)
7561         continue;
7562
7563       /* PR 17531: file: 027-161405-0.004  */
7564       if (aux->symtab == NULL)
7565         continue;
7566
7567       if (arm_sec->rel_type == SHT_REL)
7568         {
7569           offset = word & 0x7fffffff;
7570           if (offset & 0x40000000)
7571             offset |= ~ (bfd_vma) 0x7fffffff;
7572         }
7573       else if (arm_sec->rel_type == SHT_RELA)
7574         offset = rp->r_addend;
7575       else
7576         {
7577           error (_("Unknown section relocation type %d encountered\n"),
7578                  arm_sec->rel_type);
7579           break;
7580         }
7581
7582       /* PR 17531 file: 027-1241568-0.004.  */
7583       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7584         {
7585           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7586                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7587           break;
7588         }
7589
7590       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7591       offset += sym->st_value;
7592       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7593
7594       /* Check that we are processing the expected reloc type.  */
7595       if (elf_header.e_machine == EM_ARM)
7596         {
7597           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7598           if (relname == NULL)
7599             {
7600               warn (_("Skipping unknown ARM relocation type: %d\n"),
7601                     (int) ELF32_R_TYPE (rp->r_info));
7602               continue;
7603             }
7604
7605           if (streq (relname, "R_ARM_NONE"))
7606               continue;
7607
7608           if (! streq (relname, "R_ARM_PREL31"))
7609             {
7610               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7611               continue;
7612             }
7613         }
7614       else if (elf_header.e_machine == EM_TI_C6000)
7615         {
7616           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7617           if (relname == NULL)
7618             {
7619               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7620                     (int) ELF32_R_TYPE (rp->r_info));
7621               continue;
7622             }
7623
7624           if (streq (relname, "R_C6000_NONE"))
7625             continue;
7626
7627           if (! streq (relname, "R_C6000_PREL31"))
7628             {
7629               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7630               continue;
7631             }
7632
7633           prelval >>= 1;
7634         }
7635       else
7636         {
7637           /* This function currently only supports ARM and TI unwinders.  */
7638           warn (_("Only TI and ARM unwinders are currently supported\n"));
7639           break;
7640         }
7641
7642       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7643       addr->section = sym->st_shndx;
7644       addr->offset = offset;
7645
7646       if (sym_name)
7647         * sym_name = sym->st_name;
7648       break;
7649     }
7650
7651   *wordp = word;
7652   arm_sec->next_rela = rp;
7653
7654   return TRUE;
7655 }
7656
7657 static const char *tic6x_unwind_regnames[16] =
7658 {
7659   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7660   "A14", "A13", "A12", "A11", "A10",
7661   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7662 };
7663
7664 static void
7665 decode_tic6x_unwind_regmask (unsigned int mask)
7666 {
7667   int i;
7668
7669   for (i = 12; mask; mask >>= 1, i--)
7670     {
7671       if (mask & 1)
7672         {
7673           fputs (tic6x_unwind_regnames[i], stdout);
7674           if (mask > 1)
7675             fputs (", ", stdout);
7676         }
7677     }
7678 }
7679
7680 #define ADVANCE                                                 \
7681   if (remaining == 0 && more_words)                             \
7682     {                                                           \
7683       data_offset += 4;                                         \
7684       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7685                                      data_offset, & word, & addr, NULL))        \
7686         return;                                                 \
7687       remaining = 4;                                            \
7688       more_words--;                                             \
7689     }                                                           \
7690
7691 #define GET_OP(OP)                      \
7692   ADVANCE;                              \
7693   if (remaining)                        \
7694     {                                   \
7695       remaining--;                      \
7696       (OP) = word >> 24;                \
7697       word <<= 8;                       \
7698     }                                   \
7699   else                                  \
7700     {                                   \
7701       printf (_("[Truncated opcode]\n"));       \
7702       return;                           \
7703     }                                   \
7704   printf ("0x%02x ", OP)
7705
7706 static void
7707 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7708                             unsigned int               word,
7709                             unsigned int               remaining,
7710                             unsigned int               more_words,
7711                             bfd_vma                    data_offset,
7712                             Elf_Internal_Shdr *        data_sec,
7713                             struct arm_section *       data_arm_sec)
7714 {
7715   struct absaddr addr;
7716
7717   /* Decode the unwinding instructions.  */
7718   while (1)
7719     {
7720       unsigned int op, op2;
7721
7722       ADVANCE;
7723       if (remaining == 0)
7724         break;
7725       remaining--;
7726       op = word >> 24;
7727       word <<= 8;
7728
7729       printf ("  0x%02x ", op);
7730
7731       if ((op & 0xc0) == 0x00)
7732         {
7733           int offset = ((op & 0x3f) << 2) + 4;
7734
7735           printf ("     vsp = vsp + %d", offset);
7736         }
7737       else if ((op & 0xc0) == 0x40)
7738         {
7739           int offset = ((op & 0x3f) << 2) + 4;
7740
7741           printf ("     vsp = vsp - %d", offset);
7742         }
7743       else if ((op & 0xf0) == 0x80)
7744         {
7745           GET_OP (op2);
7746           if (op == 0x80 && op2 == 0)
7747             printf (_("Refuse to unwind"));
7748           else
7749             {
7750               unsigned int mask = ((op & 0x0f) << 8) | op2;
7751               int first = 1;
7752               int i;
7753
7754               printf ("pop {");
7755               for (i = 0; i < 12; i++)
7756                 if (mask & (1 << i))
7757                   {
7758                     if (first)
7759                       first = 0;
7760                     else
7761                       printf (", ");
7762                     printf ("r%d", 4 + i);
7763                   }
7764               printf ("}");
7765             }
7766         }
7767       else if ((op & 0xf0) == 0x90)
7768         {
7769           if (op == 0x9d || op == 0x9f)
7770             printf (_("     [Reserved]"));
7771           else
7772             printf ("     vsp = r%d", op & 0x0f);
7773         }
7774       else if ((op & 0xf0) == 0xa0)
7775         {
7776           int end = 4 + (op & 0x07);
7777           int first = 1;
7778           int i;
7779
7780           printf ("     pop {");
7781           for (i = 4; i <= end; i++)
7782             {
7783               if (first)
7784                 first = 0;
7785               else
7786                 printf (", ");
7787               printf ("r%d", i);
7788             }
7789           if (op & 0x08)
7790             {
7791               if (!first)
7792                 printf (", ");
7793               printf ("r14");
7794             }
7795           printf ("}");
7796         }
7797       else if (op == 0xb0)
7798         printf (_("     finish"));
7799       else if (op == 0xb1)
7800         {
7801           GET_OP (op2);
7802           if (op2 == 0 || (op2 & 0xf0) != 0)
7803             printf (_("[Spare]"));
7804           else
7805             {
7806               unsigned int mask = op2 & 0x0f;
7807               int first = 1;
7808               int i;
7809
7810               printf ("pop {");
7811               for (i = 0; i < 12; i++)
7812                 if (mask & (1 << i))
7813                   {
7814                     if (first)
7815                       first = 0;
7816                     else
7817                       printf (", ");
7818                     printf ("r%d", i);
7819                   }
7820               printf ("}");
7821             }
7822         }
7823       else if (op == 0xb2)
7824         {
7825           unsigned char buf[9];
7826           unsigned int i, len;
7827           unsigned long offset;
7828
7829           for (i = 0; i < sizeof (buf); i++)
7830             {
7831               GET_OP (buf[i]);
7832               if ((buf[i] & 0x80) == 0)
7833                 break;
7834             }
7835           if (i == sizeof (buf))
7836             printf (_("corrupt change to vsp"));
7837           else
7838             {
7839               offset = read_uleb128 (buf, &len, buf + i + 1);
7840               assert (len == i + 1);
7841               offset = offset * 4 + 0x204;
7842               printf ("vsp = vsp + %ld", offset);
7843             }
7844         }
7845       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7846         {
7847           unsigned int first, last;
7848
7849           GET_OP (op2);
7850           first = op2 >> 4;
7851           last = op2 & 0x0f;
7852           if (op == 0xc8)
7853             first = first + 16;
7854           printf ("pop {D%d", first);
7855           if (last)
7856             printf ("-D%d", first + last);
7857           printf ("}");
7858         }
7859       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7860         {
7861           unsigned int count = op & 0x07;
7862
7863           printf ("pop {D8");
7864           if (count)
7865             printf ("-D%d", 8 + count);
7866           printf ("}");
7867         }
7868       else if (op >= 0xc0 && op <= 0xc5)
7869         {
7870           unsigned int count = op & 0x07;
7871
7872           printf ("     pop {wR10");
7873           if (count)
7874             printf ("-wR%d", 10 + count);
7875           printf ("}");
7876         }
7877       else if (op == 0xc6)
7878         {
7879           unsigned int first, last;
7880
7881           GET_OP (op2);
7882           first = op2 >> 4;
7883           last = op2 & 0x0f;
7884           printf ("pop {wR%d", first);
7885           if (last)
7886             printf ("-wR%d", first + last);
7887           printf ("}");
7888         }
7889       else if (op == 0xc7)
7890         {
7891           GET_OP (op2);
7892           if (op2 == 0 || (op2 & 0xf0) != 0)
7893             printf (_("[Spare]"));
7894           else
7895             {
7896               unsigned int mask = op2 & 0x0f;
7897               int first = 1;
7898               int i;
7899
7900               printf ("pop {");
7901               for (i = 0; i < 4; i++)
7902                 if (mask & (1 << i))
7903                   {
7904                     if (first)
7905                       first = 0;
7906                     else
7907                       printf (", ");
7908                     printf ("wCGR%d", i);
7909                   }
7910               printf ("}");
7911             }
7912         }
7913       else
7914         printf (_("     [unsupported opcode]"));
7915       printf ("\n");
7916     }
7917 }
7918
7919 static void
7920 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
7921                               unsigned int               word,
7922                               unsigned int               remaining,
7923                               unsigned int               more_words,
7924                               bfd_vma                    data_offset,
7925                               Elf_Internal_Shdr *        data_sec,
7926                               struct arm_section *       data_arm_sec)
7927 {
7928   struct absaddr addr;
7929
7930   /* Decode the unwinding instructions.  */
7931   while (1)
7932     {
7933       unsigned int op, op2;
7934
7935       ADVANCE;
7936       if (remaining == 0)
7937         break;
7938       remaining--;
7939       op = word >> 24;
7940       word <<= 8;
7941
7942       printf ("  0x%02x ", op);
7943
7944       if ((op & 0xc0) == 0x00)
7945         {
7946           int offset = ((op & 0x3f) << 3) + 8;
7947           printf ("     sp = sp + %d", offset);
7948         }
7949       else if ((op & 0xc0) == 0x80)
7950         {
7951           GET_OP (op2);
7952           if (op == 0x80 && op2 == 0)
7953             printf (_("Refuse to unwind"));
7954           else
7955             {
7956               unsigned int mask = ((op & 0x1f) << 8) | op2;
7957               if (op & 0x20)
7958                 printf ("pop compact {");
7959               else
7960                 printf ("pop {");
7961
7962               decode_tic6x_unwind_regmask (mask);
7963               printf("}");
7964             }
7965         }
7966       else if ((op & 0xf0) == 0xc0)
7967         {
7968           unsigned int reg;
7969           unsigned int nregs;
7970           unsigned int i;
7971           const char *name;
7972           struct
7973           {
7974               unsigned int offset;
7975               unsigned int reg;
7976           } regpos[16];
7977
7978           /* Scan entire instruction first so that GET_OP output is not
7979              interleaved with disassembly.  */
7980           nregs = 0;
7981           for (i = 0; nregs < (op & 0xf); i++)
7982             {
7983               GET_OP (op2);
7984               reg = op2 >> 4;
7985               if (reg != 0xf)
7986                 {
7987                   regpos[nregs].offset = i * 2;
7988                   regpos[nregs].reg = reg;
7989                   nregs++;
7990                 }
7991
7992               reg = op2 & 0xf;
7993               if (reg != 0xf)
7994                 {
7995                   regpos[nregs].offset = i * 2 + 1;
7996                   regpos[nregs].reg = reg;
7997                   nregs++;
7998                 }
7999             }
8000
8001           printf (_("pop frame {"));
8002           reg = nregs - 1;
8003           for (i = i * 2; i > 0; i--)
8004             {
8005               if (regpos[reg].offset == i - 1)
8006                 {
8007                   name = tic6x_unwind_regnames[regpos[reg].reg];
8008                   if (reg > 0)
8009                     reg--;
8010                 }
8011               else
8012                 name = _("[pad]");
8013
8014               fputs (name, stdout);
8015               if (i > 1)
8016                 printf (", ");
8017             }
8018
8019           printf ("}");
8020         }
8021       else if (op == 0xd0)
8022         printf ("     MOV FP, SP");
8023       else if (op == 0xd1)
8024         printf ("     __c6xabi_pop_rts");
8025       else if (op == 0xd2)
8026         {
8027           unsigned char buf[9];
8028           unsigned int i, len;
8029           unsigned long offset;
8030
8031           for (i = 0; i < sizeof (buf); i++)
8032             {
8033               GET_OP (buf[i]);
8034               if ((buf[i] & 0x80) == 0)
8035                 break;
8036             }
8037           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8038           if (i == sizeof (buf))
8039             {
8040               printf ("<corrupt sp adjust>\n");
8041               warn (_("Corrupt stack pointer adjustment detected\n"));
8042               return;
8043             }
8044
8045           offset = read_uleb128 (buf, &len, buf + i + 1);
8046           assert (len == i + 1);
8047           offset = offset * 8 + 0x408;
8048           printf (_("sp = sp + %ld"), offset);
8049         }
8050       else if ((op & 0xf0) == 0xe0)
8051         {
8052           if ((op & 0x0f) == 7)
8053             printf ("     RETURN");
8054           else
8055             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8056         }
8057       else
8058         {
8059           printf (_("     [unsupported opcode]"));
8060         }
8061       putchar ('\n');
8062     }
8063 }
8064
8065 static bfd_vma
8066 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8067 {
8068   bfd_vma offset;
8069
8070   offset = word & 0x7fffffff;
8071   if (offset & 0x40000000)
8072     offset |= ~ (bfd_vma) 0x7fffffff;
8073
8074   if (elf_header.e_machine == EM_TI_C6000)
8075     offset <<= 1;
8076
8077   return offset + where;
8078 }
8079
8080 static void
8081 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8082                    unsigned int               word,
8083                    unsigned int               remaining,
8084                    bfd_vma                    data_offset,
8085                    Elf_Internal_Shdr *        data_sec,
8086                    struct arm_section *       data_arm_sec)
8087 {
8088   int per_index;
8089   unsigned int more_words = 0;
8090   struct absaddr addr;
8091   bfd_vma sym_name = (bfd_vma) -1;
8092
8093   if (remaining == 0)
8094     {
8095       /* Fetch the first word.
8096          Note - when decoding an object file the address extracted
8097          here will always be 0.  So we also pass in the sym_name
8098          parameter so that we can find the symbol associated with
8099          the personality routine.  */
8100       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8101                                      & word, & addr, & sym_name))
8102         return;
8103
8104       remaining = 4;
8105     }
8106
8107   if ((word & 0x80000000) == 0)
8108     {
8109       /* Expand prel31 for personality routine.  */
8110       bfd_vma fn;
8111       const char *procname;
8112
8113       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8114       printf (_("  Personality routine: "));
8115       if (fn == 0
8116           && addr.section == SHN_UNDEF && addr.offset == 0
8117           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8118         {
8119           procname = aux->strtab + sym_name;
8120           print_vma (fn, PREFIX_HEX);
8121           if (procname)
8122             {
8123               fputs (" <", stdout);
8124               fputs (procname, stdout);
8125               fputc ('>', stdout);
8126             }
8127         }
8128       else
8129         procname = arm_print_vma_and_name (aux, fn, addr);
8130       fputc ('\n', stdout);
8131
8132       /* The GCC personality routines use the standard compact
8133          encoding, starting with one byte giving the number of
8134          words.  */
8135       if (procname != NULL
8136           && (const_strneq (procname, "__gcc_personality_v0")
8137               || const_strneq (procname, "__gxx_personality_v0")
8138               || const_strneq (procname, "__gcj_personality_v0")
8139               || const_strneq (procname, "__gnu_objc_personality_v0")))
8140         {
8141           remaining = 0;
8142           more_words = 1;
8143           ADVANCE;
8144           if (!remaining)
8145             {
8146               printf (_("  [Truncated data]\n"));
8147               return;
8148             }
8149           more_words = word >> 24;
8150           word <<= 8;
8151           remaining--;
8152           per_index = -1;
8153         }
8154       else
8155         return;
8156     }
8157   else
8158     {
8159       /* ARM EHABI Section 6.3:
8160
8161          An exception-handling table entry for the compact model looks like:
8162
8163            31 30-28 27-24 23-0
8164            -- ----- ----- ----
8165             1   0   index Data for personalityRoutine[index]    */
8166
8167       if (elf_header.e_machine == EM_ARM
8168           && (word & 0x70000000))
8169         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8170
8171       per_index = (word >> 24) & 0x7f;
8172       printf (_("  Compact model index: %d\n"), per_index);
8173       if (per_index == 0)
8174         {
8175           more_words = 0;
8176           word <<= 8;
8177           remaining--;
8178         }
8179       else if (per_index < 3)
8180         {
8181           more_words = (word >> 16) & 0xff;
8182           word <<= 16;
8183           remaining -= 2;
8184         }
8185     }
8186
8187   switch (elf_header.e_machine)
8188     {
8189     case EM_ARM:
8190       if (per_index < 3)
8191         {
8192           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8193                                       data_offset, data_sec, data_arm_sec);
8194         }
8195       else
8196         {
8197           warn (_("Unknown ARM compact model index encountered\n"));
8198           printf (_("  [reserved]\n"));
8199         }
8200       break;
8201
8202     case EM_TI_C6000:
8203       if (per_index < 3)
8204         {
8205           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8206                                         data_offset, data_sec, data_arm_sec);
8207         }
8208       else if (per_index < 5)
8209         {
8210           if (((word >> 17) & 0x7f) == 0x7f)
8211             printf (_("  Restore stack from frame pointer\n"));
8212           else
8213             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8214           printf (_("  Registers restored: "));
8215           if (per_index == 4)
8216             printf (" (compact) ");
8217           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8218           putchar ('\n');
8219           printf (_("  Return register: %s\n"),
8220                   tic6x_unwind_regnames[word & 0xf]);
8221         }
8222       else
8223         printf (_("  [reserved (%d)]\n"), per_index);
8224       break;
8225
8226     default:
8227       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8228              elf_header.e_machine);
8229     }
8230
8231   /* Decode the descriptors.  Not implemented.  */
8232 }
8233
8234 static void
8235 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8236 {
8237   struct arm_section exidx_arm_sec, extab_arm_sec;
8238   unsigned int i, exidx_len;
8239   unsigned long j, nfuns;
8240
8241   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8242   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8243   exidx_len = exidx_sec->sh_size / 8;
8244
8245   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8246   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8247     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8248       aux->funtab[nfuns++] = aux->symtab[j];
8249   aux->nfuns = nfuns;
8250   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8251
8252   for (i = 0; i < exidx_len; i++)
8253     {
8254       unsigned int exidx_fn, exidx_entry;
8255       struct absaddr fn_addr, entry_addr;
8256       bfd_vma fn;
8257
8258       fputc ('\n', stdout);
8259
8260       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8261                                      8 * i, & exidx_fn, & fn_addr, NULL)
8262           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8263                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8264         {
8265           free (aux->funtab);
8266           arm_free_section (& exidx_arm_sec);
8267           arm_free_section (& extab_arm_sec);
8268           return;
8269         }
8270
8271       /* ARM EHABI, Section 5:
8272          An index table entry consists of 2 words.
8273          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8274       if (exidx_fn & 0x80000000)
8275         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8276
8277       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8278
8279       arm_print_vma_and_name (aux, fn, fn_addr);
8280       fputs (": ", stdout);
8281
8282       if (exidx_entry == 1)
8283         {
8284           print_vma (exidx_entry, PREFIX_HEX);
8285           fputs (" [cantunwind]\n", stdout);
8286         }
8287       else if (exidx_entry & 0x80000000)
8288         {
8289           print_vma (exidx_entry, PREFIX_HEX);
8290           fputc ('\n', stdout);
8291           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8292         }
8293       else
8294         {
8295           bfd_vma table, table_offset = 0;
8296           Elf_Internal_Shdr *table_sec;
8297
8298           fputs ("@", stdout);
8299           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8300           print_vma (table, PREFIX_HEX);
8301           printf ("\n");
8302
8303           /* Locate the matching .ARM.extab.  */
8304           if (entry_addr.section != SHN_UNDEF
8305               && entry_addr.section < elf_header.e_shnum)
8306             {
8307               table_sec = section_headers + entry_addr.section;
8308               table_offset = entry_addr.offset;
8309             }
8310           else
8311             {
8312               table_sec = find_section_by_address (table);
8313               if (table_sec != NULL)
8314                 table_offset = table - table_sec->sh_addr;
8315             }
8316           if (table_sec == NULL)
8317             {
8318               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8319                     (unsigned long) table);
8320               continue;
8321             }
8322           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8323                              &extab_arm_sec);
8324         }
8325     }
8326
8327   printf ("\n");
8328
8329   free (aux->funtab);
8330   arm_free_section (&exidx_arm_sec);
8331   arm_free_section (&extab_arm_sec);
8332 }
8333
8334 /* Used for both ARM and C6X unwinding tables.  */
8335
8336 static void
8337 arm_process_unwind (FILE *file)
8338 {
8339   struct arm_unw_aux_info aux;
8340   Elf_Internal_Shdr *unwsec = NULL;
8341   Elf_Internal_Shdr *strsec;
8342   Elf_Internal_Shdr *sec;
8343   unsigned long i;
8344   unsigned int sec_type;
8345
8346   switch (elf_header.e_machine)
8347     {
8348     case EM_ARM:
8349       sec_type = SHT_ARM_EXIDX;
8350       break;
8351
8352     case EM_TI_C6000:
8353       sec_type = SHT_C6000_UNWIND;
8354       break;
8355
8356     default:
8357       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8358              elf_header.e_machine);
8359       return;
8360     }
8361
8362   if (string_table == NULL)
8363     return;
8364
8365   memset (& aux, 0, sizeof (aux));
8366   aux.file = file;
8367
8368   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8369     {
8370       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8371         {
8372           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8373
8374           strsec = section_headers + sec->sh_link;
8375
8376           /* PR binutils/17531 file: 011-12666-0.004.  */
8377           if (aux.strtab != NULL)
8378             {
8379               error (_("Multiple string tables found in file.\n"));
8380               free (aux.strtab);
8381             }
8382           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8383                                  1, strsec->sh_size, _("string table"));
8384           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8385         }
8386       else if (sec->sh_type == sec_type)
8387         unwsec = sec;
8388     }
8389
8390   if (unwsec == NULL)
8391     printf (_("\nThere are no unwind sections in this file.\n"));
8392   else
8393     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8394       {
8395         if (sec->sh_type == sec_type)
8396           {
8397             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8398                     printable_section_name (sec),
8399                     (unsigned long) sec->sh_offset,
8400                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8401
8402             dump_arm_unwind (&aux, sec);
8403           }
8404       }
8405
8406   if (aux.symtab)
8407     free (aux.symtab);
8408   if (aux.strtab)
8409     free ((char *) aux.strtab);
8410 }
8411
8412 static void
8413 process_unwind (FILE * file)
8414 {
8415   struct unwind_handler
8416   {
8417     int machtype;
8418     void (* handler)(FILE *);
8419   } handlers[] =
8420   {
8421     { EM_ARM, arm_process_unwind },
8422     { EM_IA_64, ia64_process_unwind },
8423     { EM_PARISC, hppa_process_unwind },
8424     { EM_TI_C6000, arm_process_unwind },
8425     { 0, 0 }
8426   };
8427   int i;
8428
8429   if (!do_unwind)
8430     return;
8431
8432   for (i = 0; handlers[i].handler != NULL; i++)
8433     if (elf_header.e_machine == handlers[i].machtype)
8434       {
8435         handlers[i].handler (file);
8436         return;
8437       }
8438
8439   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8440           get_machine_name (elf_header.e_machine));
8441 }
8442
8443 static void
8444 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8445 {
8446   switch (entry->d_tag)
8447     {
8448     case DT_MIPS_FLAGS:
8449       if (entry->d_un.d_val == 0)
8450         printf (_("NONE"));
8451       else
8452         {
8453           static const char * opts[] =
8454           {
8455             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8456             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8457             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8458             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8459             "RLD_ORDER_SAFE"
8460           };
8461           unsigned int cnt;
8462           int first = 1;
8463
8464           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8465             if (entry->d_un.d_val & (1 << cnt))
8466               {
8467                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8468                 first = 0;
8469               }
8470         }
8471       break;
8472
8473     case DT_MIPS_IVERSION:
8474       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8475         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8476       else
8477         {
8478           char buf[40];
8479           sprintf_vma (buf, entry->d_un.d_ptr);
8480           /* Note: coded this way so that there is a single string for translation.  */
8481           printf (_("<corrupt: %s>"), buf);
8482         }
8483       break;
8484
8485     case DT_MIPS_TIME_STAMP:
8486       {
8487         char timebuf[20];
8488         struct tm * tmp;
8489         time_t atime = entry->d_un.d_val;
8490
8491         tmp = gmtime (&atime);
8492         /* PR 17531: file: 6accc532.  */
8493         if (tmp == NULL)
8494           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8495         else
8496           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8497                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8498                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8499         printf (_("Time Stamp: %s"), timebuf);
8500       }
8501       break;
8502
8503     case DT_MIPS_RLD_VERSION:
8504     case DT_MIPS_LOCAL_GOTNO:
8505     case DT_MIPS_CONFLICTNO:
8506     case DT_MIPS_LIBLISTNO:
8507     case DT_MIPS_SYMTABNO:
8508     case DT_MIPS_UNREFEXTNO:
8509     case DT_MIPS_HIPAGENO:
8510     case DT_MIPS_DELTA_CLASS_NO:
8511     case DT_MIPS_DELTA_INSTANCE_NO:
8512     case DT_MIPS_DELTA_RELOC_NO:
8513     case DT_MIPS_DELTA_SYM_NO:
8514     case DT_MIPS_DELTA_CLASSSYM_NO:
8515     case DT_MIPS_COMPACT_SIZE:
8516       print_vma (entry->d_un.d_ptr, DEC);
8517       break;
8518
8519     default:
8520       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8521     }
8522     putchar ('\n');
8523 }
8524
8525 static void
8526 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8527 {
8528   switch (entry->d_tag)
8529     {
8530     case DT_HP_DLD_FLAGS:
8531       {
8532         static struct
8533         {
8534           long int bit;
8535           const char * str;
8536         }
8537         flags[] =
8538         {
8539           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8540           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8541           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8542           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8543           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8544           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8545           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8546           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8547           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8548           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8549           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8550           { DT_HP_GST, "HP_GST" },
8551           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8552           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8553           { DT_HP_NODELETE, "HP_NODELETE" },
8554           { DT_HP_GROUP, "HP_GROUP" },
8555           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8556         };
8557         int first = 1;
8558         size_t cnt;
8559         bfd_vma val = entry->d_un.d_val;
8560
8561         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8562           if (val & flags[cnt].bit)
8563             {
8564               if (! first)
8565                 putchar (' ');
8566               fputs (flags[cnt].str, stdout);
8567               first = 0;
8568               val ^= flags[cnt].bit;
8569             }
8570
8571         if (val != 0 || first)
8572           {
8573             if (! first)
8574               putchar (' ');
8575             print_vma (val, HEX);
8576           }
8577       }
8578       break;
8579
8580     default:
8581       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8582       break;
8583     }
8584   putchar ('\n');
8585 }
8586
8587 #ifdef BFD64
8588
8589 /* VMS vs Unix time offset and factor.  */
8590
8591 #define VMS_EPOCH_OFFSET 35067168000000000LL
8592 #define VMS_GRANULARITY_FACTOR 10000000
8593
8594 /* Display a VMS time in a human readable format.  */
8595
8596 static void
8597 print_vms_time (bfd_int64_t vmstime)
8598 {
8599   struct tm *tm;
8600   time_t unxtime;
8601
8602   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8603   tm = gmtime (&unxtime);
8604   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8605           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8606           tm->tm_hour, tm->tm_min, tm->tm_sec);
8607 }
8608 #endif /* BFD64 */
8609
8610 static void
8611 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8612 {
8613   switch (entry->d_tag)
8614     {
8615     case DT_IA_64_PLT_RESERVE:
8616       /* First 3 slots reserved.  */
8617       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8618       printf (" -- ");
8619       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8620       break;
8621
8622     case DT_IA_64_VMS_LINKTIME:
8623 #ifdef BFD64
8624       print_vms_time (entry->d_un.d_val);
8625 #endif
8626       break;
8627
8628     case DT_IA_64_VMS_LNKFLAGS:
8629       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8630       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8631         printf (" CALL_DEBUG");
8632       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8633         printf (" NOP0BUFS");
8634       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8635         printf (" P0IMAGE");
8636       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8637         printf (" MKTHREADS");
8638       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8639         printf (" UPCALLS");
8640       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8641         printf (" IMGSTA");
8642       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8643         printf (" INITIALIZE");
8644       if (entry->d_un.d_val & VMS_LF_MAIN)
8645         printf (" MAIN");
8646       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8647         printf (" EXE_INIT");
8648       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8649         printf (" TBK_IN_IMG");
8650       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8651         printf (" DBG_IN_IMG");
8652       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8653         printf (" TBK_IN_DSF");
8654       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8655         printf (" DBG_IN_DSF");
8656       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8657         printf (" SIGNATURES");
8658       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8659         printf (" REL_SEG_OFF");
8660       break;
8661
8662     default:
8663       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8664       break;
8665     }
8666   putchar ('\n');
8667 }
8668
8669 static int
8670 get_32bit_dynamic_section (FILE * file)
8671 {
8672   Elf32_External_Dyn * edyn;
8673   Elf32_External_Dyn * ext;
8674   Elf_Internal_Dyn * entry;
8675
8676   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8677                                           dynamic_size, _("dynamic section"));
8678   if (!edyn)
8679     return 0;
8680
8681   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8682      might not have the luxury of section headers.  Look for the DT_NULL
8683      terminator to determine the number of entries.  */
8684   for (ext = edyn, dynamic_nent = 0;
8685        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8686        ext++)
8687     {
8688       dynamic_nent++;
8689       if (BYTE_GET (ext->d_tag) == DT_NULL)
8690         break;
8691     }
8692
8693   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8694                                                   sizeof (* entry));
8695   if (dynamic_section == NULL)
8696     {
8697       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8698              (unsigned long) dynamic_nent);
8699       free (edyn);
8700       return 0;
8701     }
8702
8703   for (ext = edyn, entry = dynamic_section;
8704        entry < dynamic_section + dynamic_nent;
8705        ext++, entry++)
8706     {
8707       entry->d_tag      = BYTE_GET (ext->d_tag);
8708       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8709     }
8710
8711   free (edyn);
8712
8713   return 1;
8714 }
8715
8716 static int
8717 get_64bit_dynamic_section (FILE * file)
8718 {
8719   Elf64_External_Dyn * edyn;
8720   Elf64_External_Dyn * ext;
8721   Elf_Internal_Dyn * entry;
8722
8723   /* Read in the data.  */
8724   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8725                                           dynamic_size, _("dynamic section"));
8726   if (!edyn)
8727     return 0;
8728
8729   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8730      might not have the luxury of section headers.  Look for the DT_NULL
8731      terminator to determine the number of entries.  */
8732   for (ext = edyn, dynamic_nent = 0;
8733        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8734        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8735        ext++)
8736     {
8737       dynamic_nent++;
8738       if (BYTE_GET (ext->d_tag) == DT_NULL)
8739         break;
8740     }
8741
8742   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8743                                                   sizeof (* entry));
8744   if (dynamic_section == NULL)
8745     {
8746       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8747              (unsigned long) dynamic_nent);
8748       free (edyn);
8749       return 0;
8750     }
8751
8752   /* Convert from external to internal formats.  */
8753   for (ext = edyn, entry = dynamic_section;
8754        entry < dynamic_section + dynamic_nent;
8755        ext++, entry++)
8756     {
8757       entry->d_tag      = BYTE_GET (ext->d_tag);
8758       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8759     }
8760
8761   free (edyn);
8762
8763   return 1;
8764 }
8765
8766 static void
8767 print_dynamic_flags (bfd_vma flags)
8768 {
8769   int first = 1;
8770
8771   while (flags)
8772     {
8773       bfd_vma flag;
8774
8775       flag = flags & - flags;
8776       flags &= ~ flag;
8777
8778       if (first)
8779         first = 0;
8780       else
8781         putc (' ', stdout);
8782
8783       switch (flag)
8784         {
8785         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8786         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8787         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8788         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8789         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8790         default:                fputs (_("unknown"), stdout); break;
8791         }
8792     }
8793   puts ("");
8794 }
8795
8796 /* Parse and display the contents of the dynamic section.  */
8797
8798 static int
8799 process_dynamic_section (FILE * file)
8800 {
8801   Elf_Internal_Dyn * entry;
8802
8803   if (dynamic_size == 0)
8804     {
8805       if (do_dynamic)
8806         printf (_("\nThere is no dynamic section in this file.\n"));
8807
8808       return 1;
8809     }
8810
8811   if (is_32bit_elf)
8812     {
8813       if (! get_32bit_dynamic_section (file))
8814         return 0;
8815     }
8816   else if (! get_64bit_dynamic_section (file))
8817     return 0;
8818
8819   /* Find the appropriate symbol table.  */
8820   if (dynamic_symbols == NULL)
8821     {
8822       for (entry = dynamic_section;
8823            entry < dynamic_section + dynamic_nent;
8824            ++entry)
8825         {
8826           Elf_Internal_Shdr section;
8827
8828           if (entry->d_tag != DT_SYMTAB)
8829             continue;
8830
8831           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8832
8833           /* Since we do not know how big the symbol table is,
8834              we default to reading in the entire file (!) and
8835              processing that.  This is overkill, I know, but it
8836              should work.  */
8837           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8838
8839           if (archive_file_offset != 0)
8840             section.sh_size = archive_file_size - section.sh_offset;
8841           else
8842             {
8843               if (fseek (file, 0, SEEK_END))
8844                 error (_("Unable to seek to end of file!\n"));
8845
8846               section.sh_size = ftell (file) - section.sh_offset;
8847             }
8848
8849           if (is_32bit_elf)
8850             section.sh_entsize = sizeof (Elf32_External_Sym);
8851           else
8852             section.sh_entsize = sizeof (Elf64_External_Sym);
8853           section.sh_name = string_table_length;
8854
8855           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8856           if (num_dynamic_syms < 1)
8857             {
8858               error (_("Unable to determine the number of symbols to load\n"));
8859               continue;
8860             }
8861         }
8862     }
8863
8864   /* Similarly find a string table.  */
8865   if (dynamic_strings == NULL)
8866     {
8867       for (entry = dynamic_section;
8868            entry < dynamic_section + dynamic_nent;
8869            ++entry)
8870         {
8871           unsigned long offset;
8872           long str_tab_len;
8873
8874           if (entry->d_tag != DT_STRTAB)
8875             continue;
8876
8877           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8878
8879           /* Since we do not know how big the string table is,
8880              we default to reading in the entire file (!) and
8881              processing that.  This is overkill, I know, but it
8882              should work.  */
8883
8884           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8885
8886           if (archive_file_offset != 0)
8887             str_tab_len = archive_file_size - offset;
8888           else
8889             {
8890               if (fseek (file, 0, SEEK_END))
8891                 error (_("Unable to seek to end of file\n"));
8892               str_tab_len = ftell (file) - offset;
8893             }
8894
8895           if (str_tab_len < 1)
8896             {
8897               error
8898                 (_("Unable to determine the length of the dynamic string table\n"));
8899               continue;
8900             }
8901
8902           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8903                                                str_tab_len,
8904                                                _("dynamic string table"));
8905           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8906           break;
8907         }
8908     }
8909
8910   /* And find the syminfo section if available.  */
8911   if (dynamic_syminfo == NULL)
8912     {
8913       unsigned long syminsz = 0;
8914
8915       for (entry = dynamic_section;
8916            entry < dynamic_section + dynamic_nent;
8917            ++entry)
8918         {
8919           if (entry->d_tag == DT_SYMINENT)
8920             {
8921               /* Note: these braces are necessary to avoid a syntax
8922                  error from the SunOS4 C compiler.  */
8923               /* PR binutils/17531: A corrupt file can trigger this test.
8924                  So do not use an assert, instead generate an error message.  */
8925               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8926                 error (_("Bad value (%d) for SYMINENT entry\n"),
8927                        (int) entry->d_un.d_val);
8928             }
8929           else if (entry->d_tag == DT_SYMINSZ)
8930             syminsz = entry->d_un.d_val;
8931           else if (entry->d_tag == DT_SYMINFO)
8932             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8933                                                       syminsz);
8934         }
8935
8936       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8937         {
8938           Elf_External_Syminfo * extsyminfo;
8939           Elf_External_Syminfo * extsym;
8940           Elf_Internal_Syminfo * syminfo;
8941
8942           /* There is a syminfo section.  Read the data.  */
8943           extsyminfo = (Elf_External_Syminfo *)
8944               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8945                         _("symbol information"));
8946           if (!extsyminfo)
8947             return 0;
8948
8949           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8950           if (dynamic_syminfo == NULL)
8951             {
8952               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8953                      (unsigned long) syminsz);
8954               return 0;
8955             }
8956
8957           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8958           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8959                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8960                ++syminfo, ++extsym)
8961             {
8962               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8963               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8964             }
8965
8966           free (extsyminfo);
8967         }
8968     }
8969
8970   if (do_dynamic && dynamic_addr)
8971     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8972             dynamic_addr, (unsigned long) dynamic_nent);
8973   if (do_dynamic)
8974     printf (_("  Tag        Type                         Name/Value\n"));
8975
8976   for (entry = dynamic_section;
8977        entry < dynamic_section + dynamic_nent;
8978        entry++)
8979     {
8980       if (do_dynamic)
8981         {
8982           const char * dtype;
8983
8984           putchar (' ');
8985           print_vma (entry->d_tag, FULL_HEX);
8986           dtype = get_dynamic_type (entry->d_tag);
8987           printf (" (%s)%*s", dtype,
8988                   ((is_32bit_elf ? 27 : 19)
8989                    - (int) strlen (dtype)),
8990                   " ");
8991         }
8992
8993       switch (entry->d_tag)
8994         {
8995         case DT_FLAGS:
8996           if (do_dynamic)
8997             print_dynamic_flags (entry->d_un.d_val);
8998           break;
8999
9000         case DT_AUXILIARY:
9001         case DT_FILTER:
9002         case DT_CONFIG:
9003         case DT_DEPAUDIT:
9004         case DT_AUDIT:
9005           if (do_dynamic)
9006             {
9007               switch (entry->d_tag)
9008                 {
9009                 case DT_AUXILIARY:
9010                   printf (_("Auxiliary library"));
9011                   break;
9012
9013                 case DT_FILTER:
9014                   printf (_("Filter library"));
9015                   break;
9016
9017                 case DT_CONFIG:
9018                   printf (_("Configuration file"));
9019                   break;
9020
9021                 case DT_DEPAUDIT:
9022                   printf (_("Dependency audit library"));
9023                   break;
9024
9025                 case DT_AUDIT:
9026                   printf (_("Audit library"));
9027                   break;
9028                 }
9029
9030               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9031                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9032               else
9033                 {
9034                   printf (": ");
9035                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9036                   putchar ('\n');
9037                 }
9038             }
9039           break;
9040
9041         case DT_FEATURE:
9042           if (do_dynamic)
9043             {
9044               printf (_("Flags:"));
9045
9046               if (entry->d_un.d_val == 0)
9047                 printf (_(" None\n"));
9048               else
9049                 {
9050                   unsigned long int val = entry->d_un.d_val;
9051
9052                   if (val & DTF_1_PARINIT)
9053                     {
9054                       printf (" PARINIT");
9055                       val ^= DTF_1_PARINIT;
9056                     }
9057                   if (val & DTF_1_CONFEXP)
9058                     {
9059                       printf (" CONFEXP");
9060                       val ^= DTF_1_CONFEXP;
9061                     }
9062                   if (val != 0)
9063                     printf (" %lx", val);
9064                   puts ("");
9065                 }
9066             }
9067           break;
9068
9069         case DT_POSFLAG_1:
9070           if (do_dynamic)
9071             {
9072               printf (_("Flags:"));
9073
9074               if (entry->d_un.d_val == 0)
9075                 printf (_(" None\n"));
9076               else
9077                 {
9078                   unsigned long int val = entry->d_un.d_val;
9079
9080                   if (val & DF_P1_LAZYLOAD)
9081                     {
9082                       printf (" LAZYLOAD");
9083                       val ^= DF_P1_LAZYLOAD;
9084                     }
9085                   if (val & DF_P1_GROUPPERM)
9086                     {
9087                       printf (" GROUPPERM");
9088                       val ^= DF_P1_GROUPPERM;
9089                     }
9090                   if (val != 0)
9091                     printf (" %lx", val);
9092                   puts ("");
9093                 }
9094             }
9095           break;
9096
9097         case DT_FLAGS_1:
9098           if (do_dynamic)
9099             {
9100               printf (_("Flags:"));
9101               if (entry->d_un.d_val == 0)
9102                 printf (_(" None\n"));
9103               else
9104                 {
9105                   unsigned long int val = entry->d_un.d_val;
9106
9107                   if (val & DF_1_NOW)
9108                     {
9109                       printf (" NOW");
9110                       val ^= DF_1_NOW;
9111                     }
9112                   if (val & DF_1_GLOBAL)
9113                     {
9114                       printf (" GLOBAL");
9115                       val ^= DF_1_GLOBAL;
9116                     }
9117                   if (val & DF_1_GROUP)
9118                     {
9119                       printf (" GROUP");
9120                       val ^= DF_1_GROUP;
9121                     }
9122                   if (val & DF_1_NODELETE)
9123                     {
9124                       printf (" NODELETE");
9125                       val ^= DF_1_NODELETE;
9126                     }
9127                   if (val & DF_1_LOADFLTR)
9128                     {
9129                       printf (" LOADFLTR");
9130                       val ^= DF_1_LOADFLTR;
9131                     }
9132                   if (val & DF_1_INITFIRST)
9133                     {
9134                       printf (" INITFIRST");
9135                       val ^= DF_1_INITFIRST;
9136                     }
9137                   if (val & DF_1_NOOPEN)
9138                     {
9139                       printf (" NOOPEN");
9140                       val ^= DF_1_NOOPEN;
9141                     }
9142                   if (val & DF_1_ORIGIN)
9143                     {
9144                       printf (" ORIGIN");
9145                       val ^= DF_1_ORIGIN;
9146                     }
9147                   if (val & DF_1_DIRECT)
9148                     {
9149                       printf (" DIRECT");
9150                       val ^= DF_1_DIRECT;
9151                     }
9152                   if (val & DF_1_TRANS)
9153                     {
9154                       printf (" TRANS");
9155                       val ^= DF_1_TRANS;
9156                     }
9157                   if (val & DF_1_INTERPOSE)
9158                     {
9159                       printf (" INTERPOSE");
9160                       val ^= DF_1_INTERPOSE;
9161                     }
9162                   if (val & DF_1_NODEFLIB)
9163                     {
9164                       printf (" NODEFLIB");
9165                       val ^= DF_1_NODEFLIB;
9166                     }
9167                   if (val & DF_1_NODUMP)
9168                     {
9169                       printf (" NODUMP");
9170                       val ^= DF_1_NODUMP;
9171                     }
9172                   if (val & DF_1_CONFALT)
9173                     {
9174                       printf (" CONFALT");
9175                       val ^= DF_1_CONFALT;
9176                     }
9177                   if (val & DF_1_ENDFILTEE)
9178                     {
9179                       printf (" ENDFILTEE");
9180                       val ^= DF_1_ENDFILTEE;
9181                     }
9182                   if (val & DF_1_DISPRELDNE)
9183                     {
9184                       printf (" DISPRELDNE");
9185                       val ^= DF_1_DISPRELDNE;
9186                     }
9187                   if (val & DF_1_DISPRELPND)
9188                     {
9189                       printf (" DISPRELPND");
9190                       val ^= DF_1_DISPRELPND;
9191                     }
9192                   if (val & DF_1_NODIRECT)
9193                     {
9194                       printf (" NODIRECT");
9195                       val ^= DF_1_NODIRECT;
9196                     }
9197                   if (val & DF_1_IGNMULDEF)
9198                     {
9199                       printf (" IGNMULDEF");
9200                       val ^= DF_1_IGNMULDEF;
9201                     }
9202                   if (val & DF_1_NOKSYMS)
9203                     {
9204                       printf (" NOKSYMS");
9205                       val ^= DF_1_NOKSYMS;
9206                     }
9207                   if (val & DF_1_NOHDR)
9208                     {
9209                       printf (" NOHDR");
9210                       val ^= DF_1_NOHDR;
9211                     }
9212                   if (val & DF_1_EDITED)
9213                     {
9214                       printf (" EDITED");
9215                       val ^= DF_1_EDITED;
9216                     }
9217                   if (val & DF_1_NORELOC)
9218                     {
9219                       printf (" NORELOC");
9220                       val ^= DF_1_NORELOC;
9221                     }
9222                   if (val & DF_1_SYMINTPOSE)
9223                     {
9224                       printf (" SYMINTPOSE");
9225                       val ^= DF_1_SYMINTPOSE;
9226                     }
9227                   if (val & DF_1_GLOBAUDIT)
9228                     {
9229                       printf (" GLOBAUDIT");
9230                       val ^= DF_1_GLOBAUDIT;
9231                     }
9232                   if (val & DF_1_SINGLETON)
9233                     {
9234                       printf (" SINGLETON");
9235                       val ^= DF_1_SINGLETON;
9236                     }
9237                   if (val != 0)
9238                     printf (" %lx", val);
9239                   puts ("");
9240                 }
9241             }
9242           break;
9243
9244         case DT_PLTREL:
9245           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9246           if (do_dynamic)
9247             puts (get_dynamic_type (entry->d_un.d_val));
9248           break;
9249
9250         case DT_NULL    :
9251         case DT_NEEDED  :
9252         case DT_PLTGOT  :
9253         case DT_HASH    :
9254         case DT_STRTAB  :
9255         case DT_SYMTAB  :
9256         case DT_RELA    :
9257         case DT_INIT    :
9258         case DT_FINI    :
9259         case DT_SONAME  :
9260         case DT_RPATH   :
9261         case DT_SYMBOLIC:
9262         case DT_REL     :
9263         case DT_DEBUG   :
9264         case DT_TEXTREL :
9265         case DT_JMPREL  :
9266         case DT_RUNPATH :
9267           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9268
9269           if (do_dynamic)
9270             {
9271               char * name;
9272
9273               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9274                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9275               else
9276                 name = NULL;
9277
9278               if (name)
9279                 {
9280                   switch (entry->d_tag)
9281                     {
9282                     case DT_NEEDED:
9283                       printf (_("Shared library: [%s]"), name);
9284
9285                       if (streq (name, program_interpreter))
9286                         printf (_(" program interpreter"));
9287                       break;
9288
9289                     case DT_SONAME:
9290                       printf (_("Library soname: [%s]"), name);
9291                       break;
9292
9293                     case DT_RPATH:
9294                       printf (_("Library rpath: [%s]"), name);
9295                       break;
9296
9297                     case DT_RUNPATH:
9298                       printf (_("Library runpath: [%s]"), name);
9299                       break;
9300
9301                     default:
9302                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9303                       break;
9304                     }
9305                 }
9306               else
9307                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9308
9309               putchar ('\n');
9310             }
9311           break;
9312
9313         case DT_PLTRELSZ:
9314         case DT_RELASZ  :
9315         case DT_STRSZ   :
9316         case DT_RELSZ   :
9317         case DT_RELAENT :
9318         case DT_SYMENT  :
9319         case DT_RELENT  :
9320           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9321         case DT_PLTPADSZ:
9322         case DT_MOVEENT :
9323         case DT_MOVESZ  :
9324         case DT_INIT_ARRAYSZ:
9325         case DT_FINI_ARRAYSZ:
9326         case DT_GNU_CONFLICTSZ:
9327         case DT_GNU_LIBLISTSZ:
9328           if (do_dynamic)
9329             {
9330               print_vma (entry->d_un.d_val, UNSIGNED);
9331               printf (_(" (bytes)\n"));
9332             }
9333           break;
9334
9335         case DT_VERDEFNUM:
9336         case DT_VERNEEDNUM:
9337         case DT_RELACOUNT:
9338         case DT_RELCOUNT:
9339           if (do_dynamic)
9340             {
9341               print_vma (entry->d_un.d_val, UNSIGNED);
9342               putchar ('\n');
9343             }
9344           break;
9345
9346         case DT_SYMINSZ:
9347         case DT_SYMINENT:
9348         case DT_SYMINFO:
9349         case DT_USED:
9350         case DT_INIT_ARRAY:
9351         case DT_FINI_ARRAY:
9352           if (do_dynamic)
9353             {
9354               if (entry->d_tag == DT_USED
9355                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9356                 {
9357                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9358
9359                   if (*name)
9360                     {
9361                       printf (_("Not needed object: [%s]\n"), name);
9362                       break;
9363                     }
9364                 }
9365
9366               print_vma (entry->d_un.d_val, PREFIX_HEX);
9367               putchar ('\n');
9368             }
9369           break;
9370
9371         case DT_BIND_NOW:
9372           /* The value of this entry is ignored.  */
9373           if (do_dynamic)
9374             putchar ('\n');
9375           break;
9376
9377         case DT_GNU_PRELINKED:
9378           if (do_dynamic)
9379             {
9380               struct tm * tmp;
9381               time_t atime = entry->d_un.d_val;
9382
9383               tmp = gmtime (&atime);
9384               /* PR 17533 file: 041-1244816-0.004.  */
9385               if (tmp == NULL)
9386                 printf (_("<corrupt time val: %lx"),
9387                         (unsigned long) atime);
9388               else
9389                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9390                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9391                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9392
9393             }
9394           break;
9395
9396         case DT_GNU_HASH:
9397           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9398           if (do_dynamic)
9399             {
9400               print_vma (entry->d_un.d_val, PREFIX_HEX);
9401               putchar ('\n');
9402             }
9403           break;
9404
9405         default:
9406           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9407             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9408               entry->d_un.d_val;
9409
9410           if (do_dynamic)
9411             {
9412               switch (elf_header.e_machine)
9413                 {
9414                 case EM_MIPS:
9415                 case EM_MIPS_RS3_LE:
9416                   dynamic_section_mips_val (entry);
9417                   break;
9418                 case EM_PARISC:
9419                   dynamic_section_parisc_val (entry);
9420                   break;
9421                 case EM_IA_64:
9422                   dynamic_section_ia64_val (entry);
9423                   break;
9424                 default:
9425                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9426                   putchar ('\n');
9427                 }
9428             }
9429           break;
9430         }
9431     }
9432
9433   return 1;
9434 }
9435
9436 static char *
9437 get_ver_flags (unsigned int flags)
9438 {
9439   static char buff[32];
9440
9441   buff[0] = 0;
9442
9443   if (flags == 0)
9444     return _("none");
9445
9446   if (flags & VER_FLG_BASE)
9447     strcat (buff, "BASE ");
9448
9449   if (flags & VER_FLG_WEAK)
9450     {
9451       if (flags & VER_FLG_BASE)
9452         strcat (buff, "| ");
9453
9454       strcat (buff, "WEAK ");
9455     }
9456
9457   if (flags & VER_FLG_INFO)
9458     {
9459       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9460         strcat (buff, "| ");
9461
9462       strcat (buff, "INFO ");
9463     }
9464
9465   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9466     strcat (buff, _("| <unknown>"));
9467
9468   return buff;
9469 }
9470
9471 /* Display the contents of the version sections.  */
9472
9473 static int
9474 process_version_sections (FILE * file)
9475 {
9476   Elf_Internal_Shdr * section;
9477   unsigned i;
9478   int found = 0;
9479
9480   if (! do_version)
9481     return 1;
9482
9483   for (i = 0, section = section_headers;
9484        i < elf_header.e_shnum;
9485        i++, section++)
9486     {
9487       switch (section->sh_type)
9488         {
9489         case SHT_GNU_verdef:
9490           {
9491             Elf_External_Verdef * edefs;
9492             unsigned int idx;
9493             unsigned int cnt;
9494             char * endbuf;
9495
9496             found = 1;
9497
9498             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9499                     printable_section_name (section),
9500                     section->sh_info);
9501
9502             printf (_("  Addr: 0x"));
9503             printf_vma (section->sh_addr);
9504             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9505                     (unsigned long) section->sh_offset, section->sh_link,
9506                     printable_section_name_from_index (section->sh_link));
9507
9508             edefs = (Elf_External_Verdef *)
9509                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9510                           _("version definition section"));
9511             if (!edefs)
9512               break;
9513             endbuf = (char *) edefs + section->sh_size;
9514
9515             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9516               {
9517                 char * vstart;
9518                 Elf_External_Verdef * edef;
9519                 Elf_Internal_Verdef ent;
9520                 Elf_External_Verdaux * eaux;
9521                 Elf_Internal_Verdaux aux;
9522                 int j;
9523                 int isum;
9524
9525                 /* Check for very large indicies.  */
9526                 if (idx > (size_t) (endbuf - (char *) edefs))
9527                   break;
9528
9529                 vstart = ((char *) edefs) + idx;
9530                 if (vstart + sizeof (*edef) > endbuf)
9531                   break;
9532
9533                 edef = (Elf_External_Verdef *) vstart;
9534
9535                 ent.vd_version = BYTE_GET (edef->vd_version);
9536                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9537                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9538                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9539                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9540                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9541                 ent.vd_next    = BYTE_GET (edef->vd_next);
9542
9543                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9544                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9545
9546                 printf (_("  Index: %d  Cnt: %d  "),
9547                         ent.vd_ndx, ent.vd_cnt);
9548
9549                 /* Check for overflow.  */
9550                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9551                   break;
9552
9553                 vstart += ent.vd_aux;
9554
9555                 eaux = (Elf_External_Verdaux *) vstart;
9556
9557                 aux.vda_name = BYTE_GET (eaux->vda_name);
9558                 aux.vda_next = BYTE_GET (eaux->vda_next);
9559
9560                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9561                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9562                 else
9563                   printf (_("Name index: %ld\n"), aux.vda_name);
9564
9565                 isum = idx + ent.vd_aux;
9566
9567                 for (j = 1; j < ent.vd_cnt; j++)
9568                   {
9569                     /* Check for overflow.  */
9570                     if (aux.vda_next > (size_t) (endbuf - vstart))
9571                       break;
9572
9573                     isum   += aux.vda_next;
9574                     vstart += aux.vda_next;
9575
9576                     eaux = (Elf_External_Verdaux *) vstart;
9577                     if (vstart + sizeof (*eaux) > endbuf)
9578                       break;
9579
9580                     aux.vda_name = BYTE_GET (eaux->vda_name);
9581                     aux.vda_next = BYTE_GET (eaux->vda_next);
9582
9583                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9584                       printf (_("  %#06x: Parent %d: %s\n"),
9585                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9586                     else
9587                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9588                               isum, j, aux.vda_name);
9589                   }
9590
9591                 if (j < ent.vd_cnt)
9592                   printf (_("  Version def aux past end of section\n"));
9593
9594                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9595                 if (idx + ent.vd_next <= idx)
9596                   break;
9597
9598                 idx += ent.vd_next;
9599               }
9600
9601             if (cnt < section->sh_info)
9602               printf (_("  Version definition past end of section\n"));
9603
9604             free (edefs);
9605           }
9606           break;
9607
9608         case SHT_GNU_verneed:
9609           {
9610             Elf_External_Verneed * eneed;
9611             unsigned int idx;
9612             unsigned int cnt;
9613             char * endbuf;
9614
9615             found = 1;
9616
9617             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9618                     printable_section_name (section), section->sh_info);
9619
9620             printf (_(" Addr: 0x"));
9621             printf_vma (section->sh_addr);
9622             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9623                     (unsigned long) section->sh_offset, section->sh_link,
9624                     printable_section_name_from_index (section->sh_link));
9625
9626             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9627                                                        section->sh_offset, 1,
9628                                                        section->sh_size,
9629                                                        _("Version Needs section"));
9630             if (!eneed)
9631               break;
9632             endbuf = (char *) eneed + section->sh_size;
9633
9634             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9635               {
9636                 Elf_External_Verneed * entry;
9637                 Elf_Internal_Verneed ent;
9638                 int j;
9639                 int isum;
9640                 char * vstart;
9641
9642                 if (idx > (size_t) (endbuf - (char *) eneed))
9643                   break;
9644
9645                 vstart = ((char *) eneed) + idx;
9646                 if (vstart + sizeof (*entry) > endbuf)
9647                   break;
9648
9649                 entry = (Elf_External_Verneed *) vstart;
9650
9651                 ent.vn_version = BYTE_GET (entry->vn_version);
9652                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9653                 ent.vn_file    = BYTE_GET (entry->vn_file);
9654                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9655                 ent.vn_next    = BYTE_GET (entry->vn_next);
9656
9657                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9658
9659                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9660                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9661                 else
9662                   printf (_("  File: %lx"), ent.vn_file);
9663
9664                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9665
9666                 /* Check for overflow.  */
9667                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9668                   break;
9669                 vstart += ent.vn_aux;
9670
9671                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9672                   {
9673                     Elf_External_Vernaux * eaux;
9674                     Elf_Internal_Vernaux aux;
9675
9676                     if (vstart + sizeof (*eaux) > endbuf)
9677                       break;
9678                     eaux = (Elf_External_Vernaux *) vstart;
9679
9680                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9681                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9682                     aux.vna_other = BYTE_GET (eaux->vna_other);
9683                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9684                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9685
9686                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9687                       printf (_("  %#06x:   Name: %s"),
9688                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9689                     else
9690                       printf (_("  %#06x:   Name index: %lx"),
9691                               isum, aux.vna_name);
9692
9693                     printf (_("  Flags: %s  Version: %d\n"),
9694                             get_ver_flags (aux.vna_flags), aux.vna_other);
9695
9696                     /* Check for overflow.  */
9697                     if (aux.vna_next > (size_t) (endbuf - vstart)
9698                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9699                       {
9700                         warn (_("Invalid vna_next field of %lx\n"),
9701                               aux.vna_next);
9702                         j = ent.vn_cnt;
9703                         break;
9704                       }
9705                     isum   += aux.vna_next;
9706                     vstart += aux.vna_next;
9707                   }
9708
9709                 if (j < ent.vn_cnt)
9710                   warn (_("Missing Version Needs auxillary information\n"));
9711
9712                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9713                   {
9714                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9715                     cnt = section->sh_info;
9716                     break;
9717                   }
9718                 idx += ent.vn_next;
9719               }
9720
9721             if (cnt < section->sh_info)
9722               warn (_("Missing Version Needs information\n"));
9723
9724             free (eneed);
9725           }
9726           break;
9727
9728         case SHT_GNU_versym:
9729           {
9730             Elf_Internal_Shdr * link_section;
9731             size_t total;
9732             unsigned int cnt;
9733             unsigned char * edata;
9734             unsigned short * data;
9735             char * strtab;
9736             Elf_Internal_Sym * symbols;
9737             Elf_Internal_Shdr * string_sec;
9738             unsigned long num_syms;
9739             long off;
9740
9741             if (section->sh_link >= elf_header.e_shnum)
9742               break;
9743
9744             link_section = section_headers + section->sh_link;
9745             total = section->sh_size / sizeof (Elf_External_Versym);
9746
9747             if (link_section->sh_link >= elf_header.e_shnum)
9748               break;
9749
9750             found = 1;
9751
9752             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9753             if (symbols == NULL)
9754               break;
9755
9756             string_sec = section_headers + link_section->sh_link;
9757
9758             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9759                                         string_sec->sh_size,
9760                                         _("version string table"));
9761             if (!strtab)
9762               {
9763                 free (symbols);
9764                 break;
9765               }
9766
9767             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9768                     printable_section_name (section), (unsigned long) total);
9769
9770             printf (_(" Addr: "));
9771             printf_vma (section->sh_addr);
9772             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9773                     (unsigned long) section->sh_offset, section->sh_link,
9774                     printable_section_name (link_section));
9775
9776             off = offset_from_vma (file,
9777                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9778                                    total * sizeof (short));
9779             edata = (unsigned char *) get_data (NULL, file, off, total,
9780                                                 sizeof (short),
9781                                                 _("version symbol data"));
9782             if (!edata)
9783               {
9784                 free (strtab);
9785                 free (symbols);
9786                 break;
9787               }
9788
9789             data = (short unsigned int *) cmalloc (total, sizeof (short));
9790
9791             for (cnt = total; cnt --;)
9792               data[cnt] = byte_get (edata + cnt * sizeof (short),
9793                                     sizeof (short));
9794
9795             free (edata);
9796
9797             for (cnt = 0; cnt < total; cnt += 4)
9798               {
9799                 int j, nn;
9800                 int check_def, check_need;
9801                 char * name;
9802
9803                 printf ("  %03x:", cnt);
9804
9805                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9806                   switch (data[cnt + j])
9807                     {
9808                     case 0:
9809                       fputs (_("   0 (*local*)    "), stdout);
9810                       break;
9811
9812                     case 1:
9813                       fputs (_("   1 (*global*)   "), stdout);
9814                       break;
9815
9816                     default:
9817                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9818                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9819
9820                       /* If this index value is greater than the size of the symbols
9821                          array, break to avoid an out-of-bounds read.  */
9822                       if ((unsigned long)(cnt + j) >= num_syms)
9823                         {
9824                           warn (_("invalid index into symbol array\n"));
9825                           break;
9826                         }
9827
9828                       check_def = 1;
9829                       check_need = 1;
9830                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9831                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9832                              != SHT_NOBITS)
9833                         {
9834                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9835                             check_def = 0;
9836                           else
9837                             check_need = 0;
9838                         }
9839
9840                       if (check_need
9841                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9842                         {
9843                           Elf_Internal_Verneed ivn;
9844                           unsigned long offset;
9845
9846                           offset = offset_from_vma
9847                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9848                              sizeof (Elf_External_Verneed));
9849
9850                           do
9851                             {
9852                               Elf_Internal_Vernaux ivna;
9853                               Elf_External_Verneed evn;
9854                               Elf_External_Vernaux evna;
9855                               unsigned long a_off;
9856
9857                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9858                                             _("version need")) == NULL)
9859                                 break;
9860
9861                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9862                               ivn.vn_next = BYTE_GET (evn.vn_next);
9863
9864                               a_off = offset + ivn.vn_aux;
9865
9866                               do
9867                                 {
9868                                   if (get_data (&evna, file, a_off, sizeof (evna),
9869                                                 1, _("version need aux (2)")) == NULL)
9870                                     {
9871                                       ivna.vna_next  = 0;
9872                                       ivna.vna_other = 0;
9873                                     }
9874                                   else
9875                                     {
9876                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9877                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9878                                     }
9879
9880                                   a_off += ivna.vna_next;
9881                                 }
9882                               while (ivna.vna_other != data[cnt + j]
9883                                      && ivna.vna_next != 0);
9884
9885                               if (ivna.vna_other == data[cnt + j])
9886                                 {
9887                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9888
9889                                   if (ivna.vna_name >= string_sec->sh_size)
9890                                     name = _("*invalid*");
9891                                   else
9892                                     name = strtab + ivna.vna_name;
9893                                   nn += printf ("(%s%-*s",
9894                                                 name,
9895                                                 12 - (int) strlen (name),
9896                                                 ")");
9897                                   check_def = 0;
9898                                   break;
9899                                 }
9900
9901                               offset += ivn.vn_next;
9902                             }
9903                           while (ivn.vn_next);
9904                         }
9905
9906                       if (check_def && data[cnt + j] != 0x8001
9907                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9908                         {
9909                           Elf_Internal_Verdef ivd;
9910                           Elf_External_Verdef evd;
9911                           unsigned long offset;
9912
9913                           offset = offset_from_vma
9914                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9915                              sizeof evd);
9916
9917                           do
9918                             {
9919                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9920                                             _("version def")) == NULL)
9921                                 {
9922                                   ivd.vd_next = 0;
9923                                   /* PR 17531: file: 046-1082287-0.004.  */
9924                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9925                                   break;
9926                                 }
9927                               else
9928                                 {
9929                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9930                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9931                                 }
9932
9933                               offset += ivd.vd_next;
9934                             }
9935                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9936                                  && ivd.vd_next != 0);
9937
9938                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9939                             {
9940                               Elf_External_Verdaux evda;
9941                               Elf_Internal_Verdaux ivda;
9942
9943                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9944
9945                               if (get_data (&evda, file,
9946                                             offset - ivd.vd_next + ivd.vd_aux,
9947                                             sizeof (evda), 1,
9948                                             _("version def aux")) == NULL)
9949                                 break;
9950
9951                               ivda.vda_name = BYTE_GET (evda.vda_name);
9952
9953                               if (ivda.vda_name >= string_sec->sh_size)
9954                                 name = _("*invalid*");
9955                               else
9956                                 name = strtab + ivda.vda_name;
9957                               nn += printf ("(%s%-*s",
9958                                             name,
9959                                             12 - (int) strlen (name),
9960                                             ")");
9961                             }
9962                         }
9963
9964                       if (nn < 18)
9965                         printf ("%*c", 18 - nn, ' ');
9966                     }
9967
9968                 putchar ('\n');
9969               }
9970
9971             free (data);
9972             free (strtab);
9973             free (symbols);
9974           }
9975           break;
9976
9977         default:
9978           break;
9979         }
9980     }
9981
9982   if (! found)
9983     printf (_("\nNo version information found in this file.\n"));
9984
9985   return 1;
9986 }
9987
9988 static const char *
9989 get_symbol_binding (unsigned int binding)
9990 {
9991   static char buff[32];
9992
9993   switch (binding)
9994     {
9995     case STB_LOCAL:     return "LOCAL";
9996     case STB_GLOBAL:    return "GLOBAL";
9997     case STB_WEAK:      return "WEAK";
9998     default:
9999       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10000         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10001                   binding);
10002       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10003         {
10004           if (binding == STB_GNU_UNIQUE
10005               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10006                   /* GNU is still using the default value 0.  */
10007                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10008             return "UNIQUE";
10009           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10010         }
10011       else
10012         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10013       return buff;
10014     }
10015 }
10016
10017 static const char *
10018 get_symbol_type (unsigned int type)
10019 {
10020   static char buff[32];
10021
10022   switch (type)
10023     {
10024     case STT_NOTYPE:    return "NOTYPE";
10025     case STT_OBJECT:    return "OBJECT";
10026     case STT_FUNC:      return "FUNC";
10027     case STT_SECTION:   return "SECTION";
10028     case STT_FILE:      return "FILE";
10029     case STT_COMMON:    return "COMMON";
10030     case STT_TLS:       return "TLS";
10031     case STT_RELC:      return "RELC";
10032     case STT_SRELC:     return "SRELC";
10033     default:
10034       if (type >= STT_LOPROC && type <= STT_HIPROC)
10035         {
10036           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10037             return "THUMB_FUNC";
10038
10039           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10040             return "REGISTER";
10041
10042           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10043             return "PARISC_MILLI";
10044
10045           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10046         }
10047       else if (type >= STT_LOOS && type <= STT_HIOS)
10048         {
10049           if (elf_header.e_machine == EM_PARISC)
10050             {
10051               if (type == STT_HP_OPAQUE)
10052                 return "HP_OPAQUE";
10053               if (type == STT_HP_STUB)
10054                 return "HP_STUB";
10055             }
10056
10057           if (type == STT_GNU_IFUNC
10058               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10059                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10060                   /* GNU is still using the default value 0.  */
10061                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10062             return "IFUNC";
10063
10064           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10065         }
10066       else
10067         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10068       return buff;
10069     }
10070 }
10071
10072 static const char *
10073 get_symbol_visibility (unsigned int visibility)
10074 {
10075   switch (visibility)
10076     {
10077     case STV_DEFAULT:   return "DEFAULT";
10078     case STV_INTERNAL:  return "INTERNAL";
10079     case STV_HIDDEN:    return "HIDDEN";
10080     case STV_PROTECTED: return "PROTECTED";
10081     default:
10082       error (_("Unrecognized visibility value: %u"), visibility);
10083       return _("<unknown>");
10084     }
10085 }
10086
10087 static const char *
10088 get_mips_symbol_other (unsigned int other)
10089 {
10090   switch (other)
10091     {
10092     case STO_OPTIONAL:
10093       return "OPTIONAL";
10094     case STO_MIPS_PLT:
10095       return "MIPS PLT";
10096     case STO_MIPS_PIC:
10097       return "MIPS PIC";
10098     case STO_MICROMIPS:
10099       return "MICROMIPS";
10100     case STO_MICROMIPS | STO_MIPS_PIC:
10101       return "MICROMIPS, MIPS PIC";
10102     case STO_MIPS16:
10103       return "MIPS16";
10104     default:
10105       return NULL;
10106     }
10107 }
10108
10109 static const char *
10110 get_ia64_symbol_other (unsigned int other)
10111 {
10112   if (is_ia64_vms ())
10113     {
10114       static char res[32];
10115
10116       res[0] = 0;
10117
10118       /* Function types is for images and .STB files only.  */
10119       switch (elf_header.e_type)
10120         {
10121         case ET_DYN:
10122         case ET_EXEC:
10123           switch (VMS_ST_FUNC_TYPE (other))
10124             {
10125             case VMS_SFT_CODE_ADDR:
10126               strcat (res, " CA");
10127               break;
10128             case VMS_SFT_SYMV_IDX:
10129               strcat (res, " VEC");
10130               break;
10131             case VMS_SFT_FD:
10132               strcat (res, " FD");
10133               break;
10134             case VMS_SFT_RESERVE:
10135               strcat (res, " RSV");
10136               break;
10137             default:
10138               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10139                     VMS_ST_FUNC_TYPE (other));
10140               strcat (res, " <unknown>");
10141               break;
10142             }
10143           break;
10144         default:
10145           break;
10146         }
10147       switch (VMS_ST_LINKAGE (other))
10148         {
10149         case VMS_STL_IGNORE:
10150           strcat (res, " IGN");
10151           break;
10152         case VMS_STL_RESERVE:
10153           strcat (res, " RSV");
10154           break;
10155         case VMS_STL_STD:
10156           strcat (res, " STD");
10157           break;
10158         case VMS_STL_LNK:
10159           strcat (res, " LNK");
10160           break;
10161         default:
10162           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10163                 VMS_ST_LINKAGE (other));
10164           strcat (res, " <unknown>");
10165           break;
10166         }
10167
10168       if (res[0] != 0)
10169         return res + 1;
10170       else
10171         return res;
10172     }
10173   return NULL;
10174 }
10175
10176 static const char *
10177 get_ppc64_symbol_other (unsigned int other)
10178 {
10179   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10180     {
10181       static char buf[32];
10182       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10183                 PPC64_LOCAL_ENTRY_OFFSET (other));
10184       return buf;
10185     }
10186   return NULL;
10187 }
10188
10189 static const char *
10190 get_symbol_other (unsigned int other)
10191 {
10192   const char * result = NULL;
10193   static char buff [32];
10194
10195   if (other == 0)
10196     return "";
10197
10198   switch (elf_header.e_machine)
10199     {
10200     case EM_MIPS:
10201       result = get_mips_symbol_other (other);
10202       break;
10203     case EM_IA_64:
10204       result = get_ia64_symbol_other (other);
10205       break;
10206     case EM_PPC64:
10207       result = get_ppc64_symbol_other (other);
10208       break;
10209     default:
10210       break;
10211     }
10212
10213   if (result)
10214     return result;
10215
10216   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10217   return buff;
10218 }
10219
10220 static const char *
10221 get_symbol_index_type (unsigned int type)
10222 {
10223   static char buff[32];
10224
10225   switch (type)
10226     {
10227     case SHN_UNDEF:     return "UND";
10228     case SHN_ABS:       return "ABS";
10229     case SHN_COMMON:    return "COM";
10230     default:
10231       if (type == SHN_IA_64_ANSI_COMMON
10232           && elf_header.e_machine == EM_IA_64
10233           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10234         return "ANSI_COM";
10235       else if ((elf_header.e_machine == EM_X86_64
10236                 || elf_header.e_machine == EM_L1OM
10237                 || elf_header.e_machine == EM_K1OM)
10238                && type == SHN_X86_64_LCOMMON)
10239         return "LARGE_COM";
10240       else if ((type == SHN_MIPS_SCOMMON
10241                 && elf_header.e_machine == EM_MIPS)
10242                || (type == SHN_TIC6X_SCOMMON
10243                    && elf_header.e_machine == EM_TI_C6000))
10244         return "SCOM";
10245       else if (type == SHN_MIPS_SUNDEFINED
10246                && elf_header.e_machine == EM_MIPS)
10247         return "SUND";
10248       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10249         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10250       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10251         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10252       else if (type >= SHN_LORESERVE)
10253         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10254       else if (type >= elf_header.e_shnum)
10255         sprintf (buff, _("bad section index[%3d]"), type);
10256       else
10257         sprintf (buff, "%3d", type);
10258       break;
10259     }
10260
10261   return buff;
10262 }
10263
10264 static bfd_vma *
10265 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10266 {
10267   unsigned char * e_data;
10268   bfd_vma * i_data;
10269
10270   /* If the size_t type is smaller than the bfd_size_type, eg because
10271      you are building a 32-bit tool on a 64-bit host, then make sure
10272      that when (number) is cast to (size_t) no information is lost.  */
10273   if (sizeof (size_t) < sizeof (bfd_size_type)
10274       && (bfd_size_type) ((size_t) number) != number)
10275     {
10276       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10277              (unsigned long long) number, ent_size);
10278       return NULL;
10279     }
10280
10281   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10282      attempting to allocate memory when the read is bound to fail.  */
10283   if (ent_size * number > current_file_size)
10284     {
10285       error (_("Invalid number of dynamic entries: %llu\n"),
10286              (unsigned long long) number);
10287       return NULL;
10288     }
10289
10290   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10291   if (e_data == NULL)
10292     {
10293       error (_("Out of memory reading %llu dynamic entries\n"),
10294              (unsigned long long) number);
10295       return NULL;
10296     }
10297
10298   if (fread (e_data, ent_size, (size_t) number, file) != number)
10299     {
10300       error (_("Unable to read in %llu bytes of dynamic data\n"),
10301              (unsigned long long) (number * ent_size));
10302       free (e_data);
10303       return NULL;
10304     }
10305
10306   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10307   if (i_data == NULL)
10308     {
10309       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10310              (unsigned long long) number);
10311       free (e_data);
10312       return NULL;
10313     }
10314
10315   while (number--)
10316     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10317
10318   free (e_data);
10319
10320   return i_data;
10321 }
10322
10323 static void
10324 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10325 {
10326   Elf_Internal_Sym * psym;
10327   int n;
10328
10329   n = print_vma (si, DEC_5);
10330   if (n < 5)
10331     fputs (&"     "[n], stdout);
10332   printf (" %3lu: ", hn);
10333
10334   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10335     {
10336       printf (_("<No info available for dynamic symbol number %lu>\n"),
10337               (unsigned long) si);
10338       return;
10339     }
10340
10341   psym = dynamic_symbols + si;
10342   print_vma (psym->st_value, LONG_HEX);
10343   putchar (' ');
10344   print_vma (psym->st_size, DEC_5);
10345
10346   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10347   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10348   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10349   /* Check to see if any other bits in the st_other field are set.
10350      Note - displaying this information disrupts the layout of the
10351      table being generated, but for the moment this case is very
10352      rare.  */
10353   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10354     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10355   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10356   if (VALID_DYNAMIC_NAME (psym->st_name))
10357     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10358   else
10359     printf (_(" <corrupt: %14ld>"), psym->st_name);
10360   putchar ('\n');
10361 }
10362
10363 static const char *
10364 get_symbol_version_string (FILE *file, int is_dynsym,
10365                            const char *strtab,
10366                            unsigned long int strtab_size,
10367                            unsigned int si, Elf_Internal_Sym *psym,
10368                            enum versioned_symbol_info *sym_info,
10369                            unsigned short *vna_other)
10370 {
10371   const char *version_string = NULL;
10372
10373   if (is_dynsym
10374       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10375     {
10376       unsigned char data[2];
10377       unsigned short vers_data;
10378       unsigned long offset;
10379       int is_nobits;
10380       int check_def;
10381
10382       offset = offset_from_vma
10383         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10384          sizeof data + si * sizeof (vers_data));
10385
10386       if (get_data (&data, file, offset + si * sizeof (vers_data),
10387                     sizeof (data), 1, _("version data")) == NULL)
10388         return NULL;
10389
10390       vers_data = byte_get (data, 2);
10391
10392       is_nobits = (section_headers != NULL
10393                    && psym->st_shndx < elf_header.e_shnum
10394                    && section_headers[psym->st_shndx].sh_type
10395                    == SHT_NOBITS);
10396
10397       check_def = (psym->st_shndx != SHN_UNDEF);
10398
10399       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10400         {
10401           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10402               && (is_nobits || ! check_def))
10403             {
10404               Elf_External_Verneed evn;
10405               Elf_Internal_Verneed ivn;
10406               Elf_Internal_Vernaux ivna;
10407
10408               /* We must test both.  */
10409               offset = offset_from_vma
10410                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10411                  sizeof evn);
10412
10413               do
10414                 {
10415                   unsigned long vna_off;
10416
10417                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10418                                 _("version need")) == NULL)
10419                     {
10420                       ivna.vna_next = 0;
10421                       ivna.vna_other = 0;
10422                       ivna.vna_name = 0;
10423                       break;
10424                     }
10425
10426                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10427                   ivn.vn_next = BYTE_GET (evn.vn_next);
10428
10429                   vna_off = offset + ivn.vn_aux;
10430
10431                   do
10432                     {
10433                       Elf_External_Vernaux evna;
10434
10435                       if (get_data (&evna, file, vna_off,
10436                                     sizeof (evna), 1,
10437                                     _("version need aux (3)")) == NULL)
10438                         {
10439                           ivna.vna_next = 0;
10440                           ivna.vna_other = 0;
10441                           ivna.vna_name = 0;
10442                         }
10443                       else
10444                         {
10445                           ivna.vna_other = BYTE_GET (evna.vna_other);
10446                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10447                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10448                         }
10449
10450                       vna_off += ivna.vna_next;
10451                     }
10452                   while (ivna.vna_other != vers_data
10453                          && ivna.vna_next != 0);
10454
10455                   if (ivna.vna_other == vers_data)
10456                     break;
10457
10458                   offset += ivn.vn_next;
10459                 }
10460               while (ivn.vn_next != 0);
10461
10462               if (ivna.vna_other == vers_data)
10463                 {
10464                   *sym_info = symbol_undefined;
10465                   *vna_other = ivna.vna_other;
10466                   version_string = (ivna.vna_name < strtab_size
10467                                     ? strtab + ivna.vna_name
10468                                     : _("<corrupt>"));
10469                   check_def = 0;
10470                 }
10471               else if (! is_nobits)
10472                 error (_("bad dynamic symbol\n"));
10473               else
10474                 check_def = 1;
10475             }
10476
10477           if (check_def)
10478             {
10479               if (vers_data != 0x8001
10480                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10481                 {
10482                   Elf_Internal_Verdef ivd;
10483                   Elf_Internal_Verdaux ivda;
10484                   Elf_External_Verdaux evda;
10485                   unsigned long off;
10486
10487                   off = offset_from_vma
10488                     (file,
10489                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10490                      sizeof (Elf_External_Verdef));
10491
10492                   do
10493                     {
10494                       Elf_External_Verdef evd;
10495
10496                       if (get_data (&evd, file, off, sizeof (evd),
10497                                     1, _("version def")) == NULL)
10498                         {
10499                           ivd.vd_ndx = 0;
10500                           ivd.vd_aux = 0;
10501                           ivd.vd_next = 0;
10502                         }
10503                       else
10504                         {
10505                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10506                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10507                           ivd.vd_next = BYTE_GET (evd.vd_next);
10508                         }
10509
10510                       off += ivd.vd_next;
10511                     }
10512                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10513                          && ivd.vd_next != 0);
10514
10515                   off -= ivd.vd_next;
10516                   off += ivd.vd_aux;
10517
10518                   if (get_data (&evda, file, off, sizeof (evda),
10519                                 1, _("version def aux")) == NULL)
10520                     return version_string;
10521
10522                   ivda.vda_name = BYTE_GET (evda.vda_name);
10523
10524                   if (psym->st_name != ivda.vda_name)
10525                     {
10526                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10527                                    ? symbol_hidden : symbol_public);
10528                       version_string = (ivda.vda_name < strtab_size
10529                                         ? strtab + ivda.vda_name
10530                                         : _("<corrupt>"));
10531                     }
10532                 }
10533             }
10534         }
10535     }
10536   return version_string;
10537 }
10538
10539 /* Dump the symbol table.  */
10540 static int
10541 process_symbol_table (FILE * file)
10542 {
10543   Elf_Internal_Shdr * section;
10544   bfd_size_type nbuckets = 0;
10545   bfd_size_type nchains = 0;
10546   bfd_vma * buckets = NULL;
10547   bfd_vma * chains = NULL;
10548   bfd_vma ngnubuckets = 0;
10549   bfd_vma * gnubuckets = NULL;
10550   bfd_vma * gnuchains = NULL;
10551   bfd_vma gnusymidx = 0;
10552   bfd_size_type ngnuchains = 0;
10553
10554   if (!do_syms && !do_dyn_syms && !do_histogram)
10555     return 1;
10556
10557   if (dynamic_info[DT_HASH]
10558       && (do_histogram
10559           || (do_using_dynamic
10560               && !do_dyn_syms
10561               && dynamic_strings != NULL)))
10562     {
10563       unsigned char nb[8];
10564       unsigned char nc[8];
10565       unsigned int hash_ent_size = 4;
10566
10567       if ((elf_header.e_machine == EM_ALPHA
10568            || elf_header.e_machine == EM_S390
10569            || elf_header.e_machine == EM_S390_OLD)
10570           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10571         hash_ent_size = 8;
10572
10573       if (fseek (file,
10574                  (archive_file_offset
10575                   + offset_from_vma (file, dynamic_info[DT_HASH],
10576                                      sizeof nb + sizeof nc)),
10577                  SEEK_SET))
10578         {
10579           error (_("Unable to seek to start of dynamic information\n"));
10580           goto no_hash;
10581         }
10582
10583       if (fread (nb, hash_ent_size, 1, file) != 1)
10584         {
10585           error (_("Failed to read in number of buckets\n"));
10586           goto no_hash;
10587         }
10588
10589       if (fread (nc, hash_ent_size, 1, file) != 1)
10590         {
10591           error (_("Failed to read in number of chains\n"));
10592           goto no_hash;
10593         }
10594
10595       nbuckets = byte_get (nb, hash_ent_size);
10596       nchains  = byte_get (nc, hash_ent_size);
10597
10598       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10599       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10600
10601     no_hash:
10602       if (buckets == NULL || chains == NULL)
10603         {
10604           if (do_using_dynamic)
10605             return 0;
10606           free (buckets);
10607           free (chains);
10608           buckets = NULL;
10609           chains = NULL;
10610           nbuckets = 0;
10611           nchains = 0;
10612         }
10613     }
10614
10615   if (dynamic_info_DT_GNU_HASH
10616       && (do_histogram
10617           || (do_using_dynamic
10618               && !do_dyn_syms
10619               && dynamic_strings != NULL)))
10620     {
10621       unsigned char nb[16];
10622       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10623       bfd_vma buckets_vma;
10624
10625       if (fseek (file,
10626                  (archive_file_offset
10627                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10628                                      sizeof nb)),
10629                  SEEK_SET))
10630         {
10631           error (_("Unable to seek to start of dynamic information\n"));
10632           goto no_gnu_hash;
10633         }
10634
10635       if (fread (nb, 16, 1, file) != 1)
10636         {
10637           error (_("Failed to read in number of buckets\n"));
10638           goto no_gnu_hash;
10639         }
10640
10641       ngnubuckets = byte_get (nb, 4);
10642       gnusymidx = byte_get (nb + 4, 4);
10643       bitmaskwords = byte_get (nb + 8, 4);
10644       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10645       if (is_32bit_elf)
10646         buckets_vma += bitmaskwords * 4;
10647       else
10648         buckets_vma += bitmaskwords * 8;
10649
10650       if (fseek (file,
10651                  (archive_file_offset
10652                   + offset_from_vma (file, buckets_vma, 4)),
10653                  SEEK_SET))
10654         {
10655           error (_("Unable to seek to start of dynamic information\n"));
10656           goto no_gnu_hash;
10657         }
10658
10659       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10660
10661       if (gnubuckets == NULL)
10662         goto no_gnu_hash;
10663
10664       for (i = 0; i < ngnubuckets; i++)
10665         if (gnubuckets[i] != 0)
10666           {
10667             if (gnubuckets[i] < gnusymidx)
10668               return 0;
10669
10670             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10671               maxchain = gnubuckets[i];
10672           }
10673
10674       if (maxchain == 0xffffffff)
10675         goto no_gnu_hash;
10676
10677       maxchain -= gnusymidx;
10678
10679       if (fseek (file,
10680                  (archive_file_offset
10681                   + offset_from_vma (file, buckets_vma
10682                                            + 4 * (ngnubuckets + maxchain), 4)),
10683                  SEEK_SET))
10684         {
10685           error (_("Unable to seek to start of dynamic information\n"));
10686           goto no_gnu_hash;
10687         }
10688
10689       do
10690         {
10691           if (fread (nb, 4, 1, file) != 1)
10692             {
10693               error (_("Failed to determine last chain length\n"));
10694               goto no_gnu_hash;
10695             }
10696
10697           if (maxchain + 1 == 0)
10698             goto no_gnu_hash;
10699
10700           ++maxchain;
10701         }
10702       while ((byte_get (nb, 4) & 1) == 0);
10703
10704       if (fseek (file,
10705                  (archive_file_offset
10706                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10707                  SEEK_SET))
10708         {
10709           error (_("Unable to seek to start of dynamic information\n"));
10710           goto no_gnu_hash;
10711         }
10712
10713       gnuchains = get_dynamic_data (file, maxchain, 4);
10714       ngnuchains = maxchain;
10715
10716     no_gnu_hash:
10717       if (gnuchains == NULL)
10718         {
10719           free (gnubuckets);
10720           gnubuckets = NULL;
10721           ngnubuckets = 0;
10722           if (do_using_dynamic)
10723             return 0;
10724         }
10725     }
10726
10727   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10728       && do_syms
10729       && do_using_dynamic
10730       && dynamic_strings != NULL
10731       && dynamic_symbols != NULL)
10732     {
10733       unsigned long hn;
10734
10735       if (dynamic_info[DT_HASH])
10736         {
10737           bfd_vma si;
10738
10739           printf (_("\nSymbol table for image:\n"));
10740           if (is_32bit_elf)
10741             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10742           else
10743             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10744
10745           for (hn = 0; hn < nbuckets; hn++)
10746             {
10747               if (! buckets[hn])
10748                 continue;
10749
10750               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10751                 print_dynamic_symbol (si, hn);
10752             }
10753         }
10754
10755       if (dynamic_info_DT_GNU_HASH)
10756         {
10757           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10758           if (is_32bit_elf)
10759             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10760           else
10761             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10762
10763           for (hn = 0; hn < ngnubuckets; ++hn)
10764             if (gnubuckets[hn] != 0)
10765               {
10766                 bfd_vma si = gnubuckets[hn];
10767                 bfd_vma off = si - gnusymidx;
10768
10769                 do
10770                   {
10771                     print_dynamic_symbol (si, hn);
10772                     si++;
10773                   }
10774                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10775               }
10776         }
10777     }
10778   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10779            && section_headers != NULL)
10780     {
10781       unsigned int i;
10782
10783       for (i = 0, section = section_headers;
10784            i < elf_header.e_shnum;
10785            i++, section++)
10786         {
10787           unsigned int si;
10788           char * strtab = NULL;
10789           unsigned long int strtab_size = 0;
10790           Elf_Internal_Sym * symtab;
10791           Elf_Internal_Sym * psym;
10792           unsigned long num_syms;
10793
10794           if ((section->sh_type != SHT_SYMTAB
10795                && section->sh_type != SHT_DYNSYM)
10796               || (!do_syms
10797                   && section->sh_type == SHT_SYMTAB))
10798             continue;
10799
10800           if (section->sh_entsize == 0)
10801             {
10802               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10803                       printable_section_name (section));
10804               continue;
10805             }
10806
10807           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10808                   printable_section_name (section),
10809                   (unsigned long) (section->sh_size / section->sh_entsize));
10810
10811           if (is_32bit_elf)
10812             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10813           else
10814             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10815
10816           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10817           if (symtab == NULL)
10818             continue;
10819
10820           if (section->sh_link == elf_header.e_shstrndx)
10821             {
10822               strtab = string_table;
10823               strtab_size = string_table_length;
10824             }
10825           else if (section->sh_link < elf_header.e_shnum)
10826             {
10827               Elf_Internal_Shdr * string_sec;
10828
10829               string_sec = section_headers + section->sh_link;
10830
10831               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10832                                           1, string_sec->sh_size,
10833                                           _("string table"));
10834               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10835             }
10836
10837           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10838             {
10839               const char *version_string;
10840               enum versioned_symbol_info sym_info;
10841               unsigned short vna_other;
10842
10843               printf ("%6d: ", si);
10844               print_vma (psym->st_value, LONG_HEX);
10845               putchar (' ');
10846               print_vma (psym->st_size, DEC_5);
10847               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10848               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10849               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10850               /* Check to see if any other bits in the st_other field are set.
10851                  Note - displaying this information disrupts the layout of the
10852                  table being generated, but for the moment this case is very rare.  */
10853               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10854                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10855               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10856               print_symbol (25, psym->st_name < strtab_size
10857                             ? strtab + psym->st_name : _("<corrupt>"));
10858
10859               version_string
10860                 = get_symbol_version_string (file,
10861                                              section->sh_type == SHT_DYNSYM,
10862                                              strtab, strtab_size, si,
10863                                              psym, &sym_info, &vna_other);
10864               if (version_string)
10865                 {
10866                   if (sym_info == symbol_undefined)
10867                     printf ("@%s (%d)", version_string, vna_other);
10868                   else
10869                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10870                             version_string);
10871                 }
10872
10873               putchar ('\n');
10874             }
10875
10876           free (symtab);
10877           if (strtab != string_table)
10878             free (strtab);
10879         }
10880     }
10881   else if (do_syms)
10882     printf
10883       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10884
10885   if (do_histogram && buckets != NULL)
10886     {
10887       unsigned long * lengths;
10888       unsigned long * counts;
10889       unsigned long hn;
10890       bfd_vma si;
10891       unsigned long maxlength = 0;
10892       unsigned long nzero_counts = 0;
10893       unsigned long nsyms = 0;
10894       unsigned long chained;
10895
10896       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10897               (unsigned long) nbuckets);
10898
10899       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10900       if (lengths == NULL)
10901         {
10902           error (_("Out of memory allocating space for histogram buckets\n"));
10903           return 0;
10904         }
10905
10906       printf (_(" Length  Number     %% of total  Coverage\n"));
10907       for (hn = 0; hn < nbuckets; ++hn)
10908         {
10909           for (si = buckets[hn], chained = 0;
10910                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10911                si = chains[si], ++chained)
10912             {
10913               ++nsyms;
10914               if (maxlength < ++lengths[hn])
10915                 ++maxlength;
10916             }
10917
10918             /* PR binutils/17531: A corrupt binary could contain broken
10919                histogram data.  Do not go into an infinite loop trying
10920                to process it.  */
10921             if (chained > nchains)
10922               {
10923                 error (_("histogram chain is corrupt\n"));
10924                 break;
10925               }
10926         }
10927
10928       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10929       if (counts == NULL)
10930         {
10931           free (lengths);
10932           error (_("Out of memory allocating space for histogram counts\n"));
10933           return 0;
10934         }
10935
10936       for (hn = 0; hn < nbuckets; ++hn)
10937         ++counts[lengths[hn]];
10938
10939       if (nbuckets > 0)
10940         {
10941           unsigned long i;
10942           printf ("      0  %-10lu (%5.1f%%)\n",
10943                   counts[0], (counts[0] * 100.0) / nbuckets);
10944           for (i = 1; i <= maxlength; ++i)
10945             {
10946               nzero_counts += counts[i] * i;
10947               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10948                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10949                       (nzero_counts * 100.0) / nsyms);
10950             }
10951         }
10952
10953       free (counts);
10954       free (lengths);
10955     }
10956
10957   if (buckets != NULL)
10958     {
10959       free (buckets);
10960       free (chains);
10961     }
10962
10963   if (do_histogram && gnubuckets != NULL)
10964     {
10965       unsigned long * lengths;
10966       unsigned long * counts;
10967       unsigned long hn;
10968       unsigned long maxlength = 0;
10969       unsigned long nzero_counts = 0;
10970       unsigned long nsyms = 0;
10971
10972       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10973               (unsigned long) ngnubuckets);
10974
10975       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10976       if (lengths == NULL)
10977         {
10978           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10979           return 0;
10980         }
10981
10982       printf (_(" Length  Number     %% of total  Coverage\n"));
10983
10984       for (hn = 0; hn < ngnubuckets; ++hn)
10985         if (gnubuckets[hn] != 0)
10986           {
10987             bfd_vma off, length = 1;
10988
10989             for (off = gnubuckets[hn] - gnusymidx;
10990                  /* PR 17531 file: 010-77222-0.004.  */
10991                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10992                  ++off)
10993               ++length;
10994             lengths[hn] = length;
10995             if (length > maxlength)
10996               maxlength = length;
10997             nsyms += length;
10998           }
10999
11000       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11001       if (counts == NULL)
11002         {
11003           free (lengths);
11004           error (_("Out of memory allocating space for gnu histogram counts\n"));
11005           return 0;
11006         }
11007
11008       for (hn = 0; hn < ngnubuckets; ++hn)
11009         ++counts[lengths[hn]];
11010
11011       if (ngnubuckets > 0)
11012         {
11013           unsigned long j;
11014           printf ("      0  %-10lu (%5.1f%%)\n",
11015                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11016           for (j = 1; j <= maxlength; ++j)
11017             {
11018               nzero_counts += counts[j] * j;
11019               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11020                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11021                       (nzero_counts * 100.0) / nsyms);
11022             }
11023         }
11024
11025       free (counts);
11026       free (lengths);
11027       free (gnubuckets);
11028       free (gnuchains);
11029     }
11030
11031   return 1;
11032 }
11033
11034 static int
11035 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11036 {
11037   unsigned int i;
11038
11039   if (dynamic_syminfo == NULL
11040       || !do_dynamic)
11041     /* No syminfo, this is ok.  */
11042     return 1;
11043
11044   /* There better should be a dynamic symbol section.  */
11045   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11046     return 0;
11047
11048   if (dynamic_addr)
11049     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11050             dynamic_syminfo_offset, dynamic_syminfo_nent);
11051
11052   printf (_(" Num: Name                           BoundTo     Flags\n"));
11053   for (i = 0; i < dynamic_syminfo_nent; ++i)
11054     {
11055       unsigned short int flags = dynamic_syminfo[i].si_flags;
11056
11057       printf ("%4d: ", i);
11058       if (i >= num_dynamic_syms)
11059         printf (_("<corrupt index>"));
11060       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11061         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11062       else
11063         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11064       putchar (' ');
11065
11066       switch (dynamic_syminfo[i].si_boundto)
11067         {
11068         case SYMINFO_BT_SELF:
11069           fputs ("SELF       ", stdout);
11070           break;
11071         case SYMINFO_BT_PARENT:
11072           fputs ("PARENT     ", stdout);
11073           break;
11074         default:
11075           if (dynamic_syminfo[i].si_boundto > 0
11076               && dynamic_syminfo[i].si_boundto < dynamic_nent
11077               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11078             {
11079               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11080               putchar (' ' );
11081             }
11082           else
11083             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11084           break;
11085         }
11086
11087       if (flags & SYMINFO_FLG_DIRECT)
11088         printf (" DIRECT");
11089       if (flags & SYMINFO_FLG_PASSTHRU)
11090         printf (" PASSTHRU");
11091       if (flags & SYMINFO_FLG_COPY)
11092         printf (" COPY");
11093       if (flags & SYMINFO_FLG_LAZYLOAD)
11094         printf (" LAZYLOAD");
11095
11096       puts ("");
11097     }
11098
11099   return 1;
11100 }
11101
11102 /* Check to see if the given reloc needs to be handled in a target specific
11103    manner.  If so then process the reloc and return TRUE otherwise return
11104    FALSE.  */
11105
11106 static bfd_boolean
11107 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11108                                 unsigned char *     start,
11109                                 Elf_Internal_Sym *  symtab)
11110 {
11111   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11112
11113   switch (elf_header.e_machine)
11114     {
11115     case EM_MSP430:
11116     case EM_MSP430_OLD:
11117       {
11118         static Elf_Internal_Sym * saved_sym = NULL;
11119
11120         switch (reloc_type)
11121           {
11122           case 10: /* R_MSP430_SYM_DIFF */
11123             if (uses_msp430x_relocs ())
11124               break;
11125           case 21: /* R_MSP430X_SYM_DIFF */
11126             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11127             return TRUE;
11128
11129           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11130           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11131             goto handle_sym_diff;
11132
11133           case 5: /* R_MSP430_16_BYTE */
11134           case 9: /* R_MSP430_8 */
11135             if (uses_msp430x_relocs ())
11136               break;
11137             goto handle_sym_diff;
11138
11139           case 2: /* R_MSP430_ABS16 */
11140           case 15: /* R_MSP430X_ABS16 */
11141             if (! uses_msp430x_relocs ())
11142               break;
11143             goto handle_sym_diff;
11144
11145           handle_sym_diff:
11146             if (saved_sym != NULL)
11147               {
11148                 bfd_vma value;
11149
11150                 value = reloc->r_addend
11151                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11152                      - saved_sym->st_value);
11153
11154                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11155
11156                 saved_sym = NULL;
11157                 return TRUE;
11158               }
11159             break;
11160
11161           default:
11162             if (saved_sym != NULL)
11163               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11164             break;
11165           }
11166         break;
11167       }
11168
11169     case EM_MN10300:
11170     case EM_CYGNUS_MN10300:
11171       {
11172         static Elf_Internal_Sym * saved_sym = NULL;
11173
11174         switch (reloc_type)
11175           {
11176           case 34: /* R_MN10300_ALIGN */
11177             return TRUE;
11178           case 33: /* R_MN10300_SYM_DIFF */
11179             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11180             return TRUE;
11181           case 1: /* R_MN10300_32 */
11182           case 2: /* R_MN10300_16 */
11183             if (saved_sym != NULL)
11184               {
11185                 bfd_vma value;
11186
11187                 value = reloc->r_addend
11188                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11189                      - saved_sym->st_value);
11190
11191                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11192
11193                 saved_sym = NULL;
11194                 return TRUE;
11195               }
11196             break;
11197           default:
11198             if (saved_sym != NULL)
11199               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11200             break;
11201           }
11202         break;
11203       }
11204
11205     case EM_RL78:
11206       {
11207         static bfd_vma saved_sym1 = 0;
11208         static bfd_vma saved_sym2 = 0;
11209         static bfd_vma value;
11210
11211         switch (reloc_type)
11212           {
11213           case 0x80: /* R_RL78_SYM.  */
11214             saved_sym1 = saved_sym2;
11215             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11216             saved_sym2 += reloc->r_addend;
11217             return TRUE;
11218
11219           case 0x83: /* R_RL78_OPsub.  */
11220             value = saved_sym1 - saved_sym2;
11221             saved_sym2 = saved_sym1 = 0;
11222             return TRUE;
11223             break;
11224
11225           case 0x41: /* R_RL78_ABS32.  */
11226             byte_put (start + reloc->r_offset, value, 4);
11227             value = 0;
11228             return TRUE;
11229
11230           case 0x43: /* R_RL78_ABS16.  */
11231             byte_put (start + reloc->r_offset, value, 2);
11232             value = 0;
11233             return TRUE;
11234
11235           default:
11236             break;
11237           }
11238         break;
11239       }
11240     }
11241
11242   return FALSE;
11243 }
11244
11245 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11246    DWARF debug sections.  This is a target specific test.  Note - we do not
11247    go through the whole including-target-headers-multiple-times route, (as
11248    we have already done with <elf/h8.h>) because this would become very
11249    messy and even then this function would have to contain target specific
11250    information (the names of the relocs instead of their numeric values).
11251    FIXME: This is not the correct way to solve this problem.  The proper way
11252    is to have target specific reloc sizing and typing functions created by
11253    the reloc-macros.h header, in the same way that it already creates the
11254    reloc naming functions.  */
11255
11256 static bfd_boolean
11257 is_32bit_abs_reloc (unsigned int reloc_type)
11258 {
11259   switch (elf_header.e_machine)
11260     {
11261     case EM_386:
11262     case EM_IAMCU:
11263       return reloc_type == 1; /* R_386_32.  */
11264     case EM_68K:
11265       return reloc_type == 1; /* R_68K_32.  */
11266     case EM_860:
11267       return reloc_type == 1; /* R_860_32.  */
11268     case EM_960:
11269       return reloc_type == 2; /* R_960_32.  */
11270     case EM_AARCH64:
11271       return reloc_type == 258; /* R_AARCH64_ABS32 */
11272     case EM_ALPHA:
11273       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11274     case EM_ARC:
11275       return reloc_type == 1; /* R_ARC_32.  */
11276     case EM_ARM:
11277       return reloc_type == 2; /* R_ARM_ABS32 */
11278     case EM_AVR_OLD:
11279     case EM_AVR:
11280       return reloc_type == 1;
11281     case EM_ADAPTEVA_EPIPHANY:
11282       return reloc_type == 3;
11283     case EM_BLACKFIN:
11284       return reloc_type == 0x12; /* R_byte4_data.  */
11285     case EM_CRIS:
11286       return reloc_type == 3; /* R_CRIS_32.  */
11287     case EM_CR16:
11288       return reloc_type == 3; /* R_CR16_NUM32.  */
11289     case EM_CRX:
11290       return reloc_type == 15; /* R_CRX_NUM32.  */
11291     case EM_CYGNUS_FRV:
11292       return reloc_type == 1;
11293     case EM_CYGNUS_D10V:
11294     case EM_D10V:
11295       return reloc_type == 6; /* R_D10V_32.  */
11296     case EM_CYGNUS_D30V:
11297     case EM_D30V:
11298       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11299     case EM_DLX:
11300       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11301     case EM_CYGNUS_FR30:
11302     case EM_FR30:
11303       return reloc_type == 3; /* R_FR30_32.  */
11304     case EM_FT32:
11305       return reloc_type == 1; /* R_FT32_32.  */
11306     case EM_H8S:
11307     case EM_H8_300:
11308     case EM_H8_300H:
11309       return reloc_type == 1; /* R_H8_DIR32.  */
11310     case EM_IA_64:
11311       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11312         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11313     case EM_IP2K_OLD:
11314     case EM_IP2K:
11315       return reloc_type == 2; /* R_IP2K_32.  */
11316     case EM_IQ2000:
11317       return reloc_type == 2; /* R_IQ2000_32.  */
11318     case EM_LATTICEMICO32:
11319       return reloc_type == 3; /* R_LM32_32.  */
11320     case EM_M32C_OLD:
11321     case EM_M32C:
11322       return reloc_type == 3; /* R_M32C_32.  */
11323     case EM_M32R:
11324       return reloc_type == 34; /* R_M32R_32_RELA.  */
11325     case EM_MCORE:
11326       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11327     case EM_CYGNUS_MEP:
11328       return reloc_type == 4; /* R_MEP_32.  */
11329     case EM_METAG:
11330       return reloc_type == 2; /* R_METAG_ADDR32.  */
11331     case EM_MICROBLAZE:
11332       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11333     case EM_MIPS:
11334       return reloc_type == 2; /* R_MIPS_32.  */
11335     case EM_MMIX:
11336       return reloc_type == 4; /* R_MMIX_32.  */
11337     case EM_CYGNUS_MN10200:
11338     case EM_MN10200:
11339       return reloc_type == 1; /* R_MN10200_32.  */
11340     case EM_CYGNUS_MN10300:
11341     case EM_MN10300:
11342       return reloc_type == 1; /* R_MN10300_32.  */
11343     case EM_MOXIE:
11344       return reloc_type == 1; /* R_MOXIE_32.  */
11345     case EM_MSP430_OLD:
11346     case EM_MSP430:
11347       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11348     case EM_MT:
11349       return reloc_type == 2; /* R_MT_32.  */
11350     case EM_NDS32:
11351       return reloc_type == 20; /* R_NDS32_RELA.  */
11352     case EM_ALTERA_NIOS2:
11353       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11354     case EM_NIOS32:
11355       return reloc_type == 1; /* R_NIOS_32.  */
11356     case EM_OR1K:
11357       return reloc_type == 1; /* R_OR1K_32.  */
11358     case EM_PARISC:
11359       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11360               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11361     case EM_PJ:
11362     case EM_PJ_OLD:
11363       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11364     case EM_PPC64:
11365       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11366     case EM_PPC:
11367       return reloc_type == 1; /* R_PPC_ADDR32.  */
11368     case EM_RL78:
11369       return reloc_type == 1; /* R_RL78_DIR32.  */
11370     case EM_RX:
11371       return reloc_type == 1; /* R_RX_DIR32.  */
11372     case EM_S370:
11373       return reloc_type == 1; /* R_I370_ADDR31.  */
11374     case EM_S390_OLD:
11375     case EM_S390:
11376       return reloc_type == 4; /* R_S390_32.  */
11377     case EM_SCORE:
11378       return reloc_type == 8; /* R_SCORE_ABS32.  */
11379     case EM_SH:
11380       return reloc_type == 1; /* R_SH_DIR32.  */
11381     case EM_SPARC32PLUS:
11382     case EM_SPARCV9:
11383     case EM_SPARC:
11384       return reloc_type == 3 /* R_SPARC_32.  */
11385         || reloc_type == 23; /* R_SPARC_UA32.  */
11386     case EM_SPU:
11387       return reloc_type == 6; /* R_SPU_ADDR32 */
11388     case EM_TI_C6000:
11389       return reloc_type == 1; /* R_C6000_ABS32.  */
11390     case EM_TILEGX:
11391       return reloc_type == 2; /* R_TILEGX_32.  */
11392     case EM_TILEPRO:
11393       return reloc_type == 1; /* R_TILEPRO_32.  */
11394     case EM_CYGNUS_V850:
11395     case EM_V850:
11396       return reloc_type == 6; /* R_V850_ABS32.  */
11397     case EM_V800:
11398       return reloc_type == 0x33; /* R_V810_WORD.  */
11399     case EM_VAX:
11400       return reloc_type == 1; /* R_VAX_32.  */
11401     case EM_VISIUM:
11402       return reloc_type == 3;  /* R_VISIUM_32. */
11403     case EM_X86_64:
11404     case EM_L1OM:
11405     case EM_K1OM:
11406       return reloc_type == 10; /* R_X86_64_32.  */
11407     case EM_XC16X:
11408     case EM_C166:
11409       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11410     case EM_XGATE:
11411       return reloc_type == 4; /* R_XGATE_32.  */
11412     case EM_XSTORMY16:
11413       return reloc_type == 1; /* R_XSTROMY16_32.  */
11414     case EM_XTENSA_OLD:
11415     case EM_XTENSA:
11416       return reloc_type == 1; /* R_XTENSA_32.  */
11417     default:
11418       {
11419         static unsigned int prev_warn = 0;
11420
11421         /* Avoid repeating the same warning multiple times.  */
11422         if (prev_warn != elf_header.e_machine)
11423           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11424                  elf_header.e_machine);
11425         prev_warn = elf_header.e_machine;
11426         return FALSE;
11427       }
11428     }
11429 }
11430
11431 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11432    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11433
11434 static bfd_boolean
11435 is_32bit_pcrel_reloc (unsigned int reloc_type)
11436 {
11437   switch (elf_header.e_machine)
11438     {
11439     case EM_386:
11440     case EM_IAMCU:
11441       return reloc_type == 2;  /* R_386_PC32.  */
11442     case EM_68K:
11443       return reloc_type == 4;  /* R_68K_PC32.  */
11444     case EM_AARCH64:
11445       return reloc_type == 261; /* R_AARCH64_PREL32 */
11446     case EM_ADAPTEVA_EPIPHANY:
11447       return reloc_type == 6;
11448     case EM_ALPHA:
11449       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11450     case EM_ARM:
11451       return reloc_type == 3;  /* R_ARM_REL32 */
11452     case EM_MICROBLAZE:
11453       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11454     case EM_OR1K:
11455       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11456     case EM_PARISC:
11457       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11458     case EM_PPC:
11459       return reloc_type == 26; /* R_PPC_REL32.  */
11460     case EM_PPC64:
11461       return reloc_type == 26; /* R_PPC64_REL32.  */
11462     case EM_S390_OLD:
11463     case EM_S390:
11464       return reloc_type == 5;  /* R_390_PC32.  */
11465     case EM_SH:
11466       return reloc_type == 2;  /* R_SH_REL32.  */
11467     case EM_SPARC32PLUS:
11468     case EM_SPARCV9:
11469     case EM_SPARC:
11470       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11471     case EM_SPU:
11472       return reloc_type == 13; /* R_SPU_REL32.  */
11473     case EM_TILEGX:
11474       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11475     case EM_TILEPRO:
11476       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11477     case EM_VISIUM:
11478       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11479     case EM_X86_64:
11480     case EM_L1OM:
11481     case EM_K1OM:
11482       return reloc_type == 2;  /* R_X86_64_PC32.  */
11483     case EM_XTENSA_OLD:
11484     case EM_XTENSA:
11485       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11486     default:
11487       /* Do not abort or issue an error message here.  Not all targets use
11488          pc-relative 32-bit relocs in their DWARF debug information and we
11489          have already tested for target coverage in is_32bit_abs_reloc.  A
11490          more helpful warning message will be generated by apply_relocations
11491          anyway, so just return.  */
11492       return FALSE;
11493     }
11494 }
11495
11496 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11497    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11498
11499 static bfd_boolean
11500 is_64bit_abs_reloc (unsigned int reloc_type)
11501 {
11502   switch (elf_header.e_machine)
11503     {
11504     case EM_AARCH64:
11505       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11506     case EM_ALPHA:
11507       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11508     case EM_IA_64:
11509       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11510     case EM_PARISC:
11511       return reloc_type == 80; /* R_PARISC_DIR64.  */
11512     case EM_PPC64:
11513       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11514     case EM_SPARC32PLUS:
11515     case EM_SPARCV9:
11516     case EM_SPARC:
11517       return reloc_type == 54; /* R_SPARC_UA64.  */
11518     case EM_X86_64:
11519     case EM_L1OM:
11520     case EM_K1OM:
11521       return reloc_type == 1; /* R_X86_64_64.  */
11522     case EM_S390_OLD:
11523     case EM_S390:
11524       return reloc_type == 22;  /* R_S390_64.  */
11525     case EM_TILEGX:
11526       return reloc_type == 1; /* R_TILEGX_64.  */
11527     case EM_MIPS:
11528       return reloc_type == 18;  /* R_MIPS_64.  */
11529     default:
11530       return FALSE;
11531     }
11532 }
11533
11534 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11535    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11536
11537 static bfd_boolean
11538 is_64bit_pcrel_reloc (unsigned int reloc_type)
11539 {
11540   switch (elf_header.e_machine)
11541     {
11542     case EM_AARCH64:
11543       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11544     case EM_ALPHA:
11545       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11546     case EM_IA_64:
11547       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11548     case EM_PARISC:
11549       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11550     case EM_PPC64:
11551       return reloc_type == 44; /* R_PPC64_REL64.  */
11552     case EM_SPARC32PLUS:
11553     case EM_SPARCV9:
11554     case EM_SPARC:
11555       return reloc_type == 46; /* R_SPARC_DISP64.  */
11556     case EM_X86_64:
11557     case EM_L1OM:
11558     case EM_K1OM:
11559       return reloc_type == 24; /* R_X86_64_PC64.  */
11560     case EM_S390_OLD:
11561     case EM_S390:
11562       return reloc_type == 23;  /* R_S390_PC64.  */
11563     case EM_TILEGX:
11564       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11565     default:
11566       return FALSE;
11567     }
11568 }
11569
11570 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11571    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11572
11573 static bfd_boolean
11574 is_24bit_abs_reloc (unsigned int reloc_type)
11575 {
11576   switch (elf_header.e_machine)
11577     {
11578     case EM_CYGNUS_MN10200:
11579     case EM_MN10200:
11580       return reloc_type == 4; /* R_MN10200_24.  */
11581     default:
11582       return FALSE;
11583     }
11584 }
11585
11586 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11587    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11588
11589 static bfd_boolean
11590 is_16bit_abs_reloc (unsigned int reloc_type)
11591 {
11592   switch (elf_header.e_machine)
11593     {
11594     case EM_AVR_OLD:
11595     case EM_AVR:
11596       return reloc_type == 4; /* R_AVR_16.  */
11597     case EM_ADAPTEVA_EPIPHANY:
11598       return reloc_type == 5;
11599     case EM_CYGNUS_D10V:
11600     case EM_D10V:
11601       return reloc_type == 3; /* R_D10V_16.  */
11602     case EM_H8S:
11603     case EM_H8_300:
11604     case EM_H8_300H:
11605       return reloc_type == R_H8_DIR16;
11606     case EM_IP2K_OLD:
11607     case EM_IP2K:
11608       return reloc_type == 1; /* R_IP2K_16.  */
11609     case EM_M32C_OLD:
11610     case EM_M32C:
11611       return reloc_type == 1; /* R_M32C_16 */
11612     case EM_MSP430:
11613       if (uses_msp430x_relocs ())
11614         return reloc_type == 2; /* R_MSP430_ABS16.  */
11615     case EM_MSP430_OLD:
11616       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11617     case EM_NDS32:
11618       return reloc_type == 19; /* R_NDS32_RELA.  */
11619     case EM_ALTERA_NIOS2:
11620       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11621     case EM_NIOS32:
11622       return reloc_type == 9; /* R_NIOS_16.  */
11623     case EM_OR1K:
11624       return reloc_type == 2; /* R_OR1K_16.  */
11625     case EM_TI_C6000:
11626       return reloc_type == 2; /* R_C6000_ABS16.  */
11627     case EM_XC16X:
11628     case EM_C166:
11629       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11630     case EM_CYGNUS_MN10200:
11631     case EM_MN10200:
11632       return reloc_type == 2; /* R_MN10200_16.  */
11633     case EM_CYGNUS_MN10300:
11634     case EM_MN10300:
11635       return reloc_type == 2; /* R_MN10300_16.  */
11636     case EM_VISIUM:
11637       return reloc_type == 2; /* R_VISIUM_16. */
11638     case EM_XGATE:
11639       return reloc_type == 3; /* R_XGATE_16.  */
11640     default:
11641       return FALSE;
11642     }
11643 }
11644
11645 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11646    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11647
11648 static bfd_boolean
11649 is_none_reloc (unsigned int reloc_type)
11650 {
11651   switch (elf_header.e_machine)
11652     {
11653     case EM_68K:     /* R_68K_NONE.  */
11654     case EM_386:     /* R_386_NONE.  */
11655     case EM_SPARC32PLUS:
11656     case EM_SPARCV9:
11657     case EM_SPARC:   /* R_SPARC_NONE.  */
11658     case EM_MIPS:    /* R_MIPS_NONE.  */
11659     case EM_PARISC:  /* R_PARISC_NONE.  */
11660     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11661     case EM_ADAPTEVA_EPIPHANY:
11662     case EM_PPC:     /* R_PPC_NONE.  */
11663     case EM_PPC64:   /* R_PPC64_NONE.  */
11664     case EM_ARM:     /* R_ARM_NONE.  */
11665     case EM_IA_64:   /* R_IA64_NONE.  */
11666     case EM_SH:      /* R_SH_NONE.  */
11667     case EM_S390_OLD:
11668     case EM_S390:    /* R_390_NONE.  */
11669     case EM_CRIS:    /* R_CRIS_NONE.  */
11670     case EM_X86_64:  /* R_X86_64_NONE.  */
11671     case EM_L1OM:    /* R_X86_64_NONE.  */
11672     case EM_K1OM:    /* R_X86_64_NONE.  */
11673     case EM_MN10300: /* R_MN10300_NONE.  */
11674     case EM_FT32:    /* R_FT32_NONE.  */
11675     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11676     case EM_M32R:    /* R_M32R_NONE.  */
11677     case EM_TI_C6000:/* R_C6000_NONE.  */
11678     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11679     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11680     case EM_XC16X:
11681     case EM_C166:    /* R_XC16X_NONE.  */
11682     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11683     case EM_NIOS32:  /* R_NIOS_NONE.  */
11684     case EM_OR1K:    /* R_OR1K_NONE. */
11685       return reloc_type == 0;
11686     case EM_AARCH64:
11687       return reloc_type == 0 || reloc_type == 256;
11688     case EM_NDS32:
11689       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11690               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11691               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11692               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11693               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11694     case EM_XTENSA_OLD:
11695     case EM_XTENSA:
11696       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11697               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11698               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11699               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11700     case EM_METAG:
11701       return reloc_type == 3; /* R_METAG_NONE.  */
11702     }
11703   return FALSE;
11704 }
11705
11706 /* Returns TRUE if there is a relocation against
11707    section NAME at OFFSET bytes.  */
11708
11709 bfd_boolean
11710 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11711 {
11712   Elf_Internal_Rela * relocs;
11713   Elf_Internal_Rela * rp;
11714
11715   if (dsec == NULL || dsec->reloc_info == NULL)
11716     return FALSE;
11717
11718   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11719
11720   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11721     if (rp->r_offset == offset)
11722       return TRUE;
11723
11724    return FALSE;
11725 }
11726
11727 /* Apply relocations to a section.
11728    Note: So far support has been added only for those relocations
11729    which can be found in debug sections.
11730    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11731    loaded relocs.  It is then the caller's responsibility to free them.
11732    FIXME: Add support for more relocations ?  */
11733
11734 static void
11735 apply_relocations (void *                     file,
11736                    const Elf_Internal_Shdr *  section,
11737                    unsigned char *            start,
11738                    bfd_size_type              size,
11739                    void **                     relocs_return,
11740                    unsigned long *            num_relocs_return)
11741 {
11742   Elf_Internal_Shdr * relsec;
11743   unsigned char * end = start + size;
11744
11745   if (relocs_return != NULL)
11746     {
11747       * (Elf_Internal_Rela **) relocs_return = NULL;
11748       * num_relocs_return = 0;
11749     }
11750
11751   if (elf_header.e_type != ET_REL)
11752     return;
11753
11754   /* Find the reloc section associated with the section.  */
11755   for (relsec = section_headers;
11756        relsec < section_headers + elf_header.e_shnum;
11757        ++relsec)
11758     {
11759       bfd_boolean is_rela;
11760       unsigned long num_relocs;
11761       Elf_Internal_Rela * relocs;
11762       Elf_Internal_Rela * rp;
11763       Elf_Internal_Shdr * symsec;
11764       Elf_Internal_Sym * symtab;
11765       unsigned long num_syms;
11766       Elf_Internal_Sym * sym;
11767
11768       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11769           || relsec->sh_info >= elf_header.e_shnum
11770           || section_headers + relsec->sh_info != section
11771           || relsec->sh_size == 0
11772           || relsec->sh_link >= elf_header.e_shnum)
11773         continue;
11774
11775       is_rela = relsec->sh_type == SHT_RELA;
11776
11777       if (is_rela)
11778         {
11779           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11780                                   relsec->sh_size, & relocs, & num_relocs))
11781             return;
11782         }
11783       else
11784         {
11785           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11786                                  relsec->sh_size, & relocs, & num_relocs))
11787             return;
11788         }
11789
11790       /* SH uses RELA but uses in place value instead of the addend field.  */
11791       if (elf_header.e_machine == EM_SH)
11792         is_rela = FALSE;
11793
11794       symsec = section_headers + relsec->sh_link;
11795       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11796
11797       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11798         {
11799           bfd_vma         addend;
11800           unsigned int    reloc_type;
11801           unsigned int    reloc_size;
11802           unsigned char * rloc;
11803           unsigned long   sym_index;
11804
11805           reloc_type = get_reloc_type (rp->r_info);
11806
11807           if (target_specific_reloc_handling (rp, start, symtab))
11808             continue;
11809           else if (is_none_reloc (reloc_type))
11810             continue;
11811           else if (is_32bit_abs_reloc (reloc_type)
11812                    || is_32bit_pcrel_reloc (reloc_type))
11813             reloc_size = 4;
11814           else if (is_64bit_abs_reloc (reloc_type)
11815                    || is_64bit_pcrel_reloc (reloc_type))
11816             reloc_size = 8;
11817           else if (is_24bit_abs_reloc (reloc_type))
11818             reloc_size = 3;
11819           else if (is_16bit_abs_reloc (reloc_type))
11820             reloc_size = 2;
11821           else
11822             {
11823               static unsigned int prev_reloc = 0;
11824               if (reloc_type != prev_reloc)
11825                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11826                       reloc_type, printable_section_name (section));
11827               prev_reloc = reloc_type;
11828               continue;
11829             }
11830
11831           rloc = start + rp->r_offset;
11832           if ((rloc + reloc_size) > end || (rloc < start))
11833             {
11834               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11835                     (unsigned long) rp->r_offset,
11836                     printable_section_name (section));
11837               continue;
11838             }
11839
11840           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11841           if (sym_index >= num_syms)
11842             {
11843               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11844                     sym_index, printable_section_name (section));
11845               continue;
11846             }
11847           sym = symtab + sym_index;
11848
11849           /* If the reloc has a symbol associated with it,
11850              make sure that it is of an appropriate type.
11851
11852              Relocations against symbols without type can happen.
11853              Gcc -feliminate-dwarf2-dups may generate symbols
11854              without type for debug info.
11855
11856              Icc generates relocations against function symbols
11857              instead of local labels.
11858
11859              Relocations against object symbols can happen, eg when
11860              referencing a global array.  For an example of this see
11861              the _clz.o binary in libgcc.a.  */
11862           if (sym != symtab
11863               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11864             {
11865               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11866                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11867                     (long int)(rp - relocs),
11868                     printable_section_name (relsec));
11869               continue;
11870             }
11871
11872           addend = 0;
11873           if (is_rela)
11874             addend += rp->r_addend;
11875           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11876              partial_inplace.  */
11877           if (!is_rela
11878               || (elf_header.e_machine == EM_XTENSA
11879                   && reloc_type == 1)
11880               || ((elf_header.e_machine == EM_PJ
11881                    || elf_header.e_machine == EM_PJ_OLD)
11882                   && reloc_type == 1)
11883               || ((elf_header.e_machine == EM_D30V
11884                    || elf_header.e_machine == EM_CYGNUS_D30V)
11885                   && reloc_type == 12))
11886             addend += byte_get (rloc, reloc_size);
11887
11888           if (is_32bit_pcrel_reloc (reloc_type)
11889               || is_64bit_pcrel_reloc (reloc_type))
11890             {
11891               /* On HPPA, all pc-relative relocations are biased by 8.  */
11892               if (elf_header.e_machine == EM_PARISC)
11893                 addend -= 8;
11894               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11895                         reloc_size);
11896             }
11897           else
11898             byte_put (rloc, addend + sym->st_value, reloc_size);
11899         }
11900
11901       free (symtab);
11902
11903       if (relocs_return)
11904         {
11905           * (Elf_Internal_Rela **) relocs_return = relocs;
11906           * num_relocs_return = num_relocs;
11907         }
11908       else
11909         free (relocs);
11910
11911       break;
11912     }
11913 }
11914
11915 #ifdef SUPPORT_DISASSEMBLY
11916 static int
11917 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11918 {
11919   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11920
11921   /* FIXME: XXX -- to be done --- XXX */
11922
11923   return 1;
11924 }
11925 #endif
11926
11927 /* Reads in the contents of SECTION from FILE, returning a pointer
11928    to a malloc'ed buffer or NULL if something went wrong.  */
11929
11930 static char *
11931 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11932 {
11933   bfd_size_type num_bytes;
11934
11935   num_bytes = section->sh_size;
11936
11937   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11938     {
11939       printf (_("\nSection '%s' has no data to dump.\n"),
11940               printable_section_name (section));
11941       return NULL;
11942     }
11943
11944   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11945                              _("section contents"));
11946 }
11947
11948 /* Uncompresses a section that was compressed using zlib, in place.  */
11949
11950 static bfd_boolean
11951 uncompress_section_contents (unsigned char **buffer,
11952                              dwarf_size_type uncompressed_size,
11953                              dwarf_size_type *size)
11954 {
11955   dwarf_size_type compressed_size = *size;
11956   unsigned char * compressed_buffer = *buffer;
11957   unsigned char * uncompressed_buffer;
11958   z_stream strm;
11959   int rc;
11960
11961   /* It is possible the section consists of several compressed
11962      buffers concatenated together, so we uncompress in a loop.  */
11963   /* PR 18313: The state field in the z_stream structure is supposed
11964      to be invisible to the user (ie us), but some compilers will
11965      still complain about it being used without initialisation.  So
11966      we first zero the entire z_stream structure and then set the fields
11967      that we need.  */
11968   memset (& strm, 0, sizeof strm);
11969   strm.avail_in = compressed_size;
11970   strm.next_in = (Bytef *) compressed_buffer;
11971   strm.avail_out = uncompressed_size;
11972   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11973
11974   rc = inflateInit (& strm);
11975   while (strm.avail_in > 0)
11976     {
11977       if (rc != Z_OK)
11978         goto fail;
11979       strm.next_out = ((Bytef *) uncompressed_buffer
11980                        + (uncompressed_size - strm.avail_out));
11981       rc = inflate (&strm, Z_FINISH);
11982       if (rc != Z_STREAM_END)
11983         goto fail;
11984       rc = inflateReset (& strm);
11985     }
11986   rc = inflateEnd (& strm);
11987   if (rc != Z_OK
11988       || strm.avail_out != 0)
11989     goto fail;
11990
11991   *buffer = uncompressed_buffer;
11992   *size = uncompressed_size;
11993   return TRUE;
11994
11995  fail:
11996   free (uncompressed_buffer);
11997   /* Indicate decompression failure.  */
11998   *buffer = NULL;
11999   return FALSE;
12000 }
12001
12002 static void
12003 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12004 {
12005   Elf_Internal_Shdr *  relsec;
12006   bfd_size_type        num_bytes;
12007   unsigned char *      data;
12008   unsigned char *      end;
12009   unsigned char *      real_start;
12010   unsigned char *      start;
12011   bfd_boolean          some_strings_shown;
12012
12013   real_start = start = (unsigned char *) get_section_contents (section,
12014                                                                file);
12015   if (start == NULL)
12016     return;
12017   num_bytes = section->sh_size;
12018
12019   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12020
12021   if (decompress_dumps)
12022     {
12023       dwarf_size_type new_size = num_bytes;
12024       dwarf_size_type uncompressed_size = 0;
12025
12026       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12027         {
12028           Elf_Internal_Chdr chdr;
12029           unsigned int compression_header_size
12030             = get_compression_header (& chdr, (unsigned char *) start);
12031
12032           if (chdr.ch_type == ELFCOMPRESS_ZLIB
12033               && chdr.ch_addralign == section->sh_addralign)
12034             {
12035               uncompressed_size = chdr.ch_size;
12036               start += compression_header_size;
12037               new_size -= compression_header_size;
12038             }
12039         }
12040       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12041         {
12042           /* Read the zlib header.  In this case, it should be "ZLIB"
12043              followed by the uncompressed section size, 8 bytes in
12044              big-endian order.  */
12045           uncompressed_size = start[4]; uncompressed_size <<= 8;
12046           uncompressed_size += start[5]; uncompressed_size <<= 8;
12047           uncompressed_size += start[6]; uncompressed_size <<= 8;
12048           uncompressed_size += start[7]; uncompressed_size <<= 8;
12049           uncompressed_size += start[8]; uncompressed_size <<= 8;
12050           uncompressed_size += start[9]; uncompressed_size <<= 8;
12051           uncompressed_size += start[10]; uncompressed_size <<= 8;
12052           uncompressed_size += start[11];
12053           start += 12;
12054           new_size -= 12;
12055         }
12056
12057       if (uncompressed_size
12058           && uncompress_section_contents (& start,
12059                                           uncompressed_size, & new_size))
12060         num_bytes = new_size;
12061     }
12062
12063   /* If the section being dumped has relocations against it the user might
12064      be expecting these relocations to have been applied.  Check for this
12065      case and issue a warning message in order to avoid confusion.
12066      FIXME: Maybe we ought to have an option that dumps a section with
12067      relocs applied ?  */
12068   for (relsec = section_headers;
12069        relsec < section_headers + elf_header.e_shnum;
12070        ++relsec)
12071     {
12072       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12073           || relsec->sh_info >= elf_header.e_shnum
12074           || section_headers + relsec->sh_info != section
12075           || relsec->sh_size == 0
12076           || relsec->sh_link >= elf_header.e_shnum)
12077         continue;
12078
12079       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12080       break;
12081     }
12082
12083   data = start;
12084   end  = start + num_bytes;
12085   some_strings_shown = FALSE;
12086
12087   while (data < end)
12088     {
12089       while (!ISPRINT (* data))
12090         if (++ data >= end)
12091           break;
12092
12093       if (data < end)
12094         {
12095           size_t maxlen = end - data;
12096
12097 #ifndef __MSVCRT__
12098           /* PR 11128: Use two separate invocations in order to work
12099              around bugs in the Solaris 8 implementation of printf.  */
12100           printf ("  [%6tx]  ", data - start);
12101 #else
12102           printf ("  [%6Ix]  ", (size_t) (data - start));
12103 #endif
12104           if (maxlen > 0)
12105             {
12106               print_symbol ((int) maxlen, (const char *) data);
12107               putchar ('\n');
12108               data += strnlen ((const char *) data, maxlen);
12109             }
12110           else
12111             {
12112               printf (_("<corrupt>\n"));
12113               data = end;
12114             }
12115           some_strings_shown = TRUE;
12116         }
12117     }
12118
12119   if (! some_strings_shown)
12120     printf (_("  No strings found in this section."));
12121
12122   free (real_start);
12123
12124   putchar ('\n');
12125 }
12126
12127 static void
12128 dump_section_as_bytes (Elf_Internal_Shdr * section,
12129                        FILE * file,
12130                        bfd_boolean relocate)
12131 {
12132   Elf_Internal_Shdr * relsec;
12133   bfd_size_type       bytes;
12134   bfd_size_type       section_size;
12135   bfd_vma             addr;
12136   unsigned char *     data;
12137   unsigned char *     real_start;
12138   unsigned char *     start;
12139
12140   real_start = start = (unsigned char *) get_section_contents (section, file);
12141   if (start == NULL)
12142     return;
12143   section_size = section->sh_size;
12144
12145   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12146
12147   if (decompress_dumps)
12148     {
12149       dwarf_size_type new_size = section_size;
12150       dwarf_size_type uncompressed_size = 0;
12151
12152       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12153         {
12154           Elf_Internal_Chdr chdr;
12155           unsigned int compression_header_size
12156             = get_compression_header (& chdr, start);
12157
12158           if (chdr.ch_type == ELFCOMPRESS_ZLIB
12159               && chdr.ch_addralign == section->sh_addralign)
12160             {
12161               uncompressed_size = chdr.ch_size;
12162               start += compression_header_size;
12163               new_size -= compression_header_size;
12164             }
12165         }
12166       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12167         {
12168           /* Read the zlib header.  In this case, it should be "ZLIB"
12169              followed by the uncompressed section size, 8 bytes in
12170              big-endian order.  */
12171           uncompressed_size = start[4]; uncompressed_size <<= 8;
12172           uncompressed_size += start[5]; uncompressed_size <<= 8;
12173           uncompressed_size += start[6]; uncompressed_size <<= 8;
12174           uncompressed_size += start[7]; uncompressed_size <<= 8;
12175           uncompressed_size += start[8]; uncompressed_size <<= 8;
12176           uncompressed_size += start[9]; uncompressed_size <<= 8;
12177           uncompressed_size += start[10]; uncompressed_size <<= 8;
12178           uncompressed_size += start[11];
12179           start += 12;
12180           new_size -= 12;
12181         }
12182
12183       if (uncompressed_size
12184           && uncompress_section_contents (& start, uncompressed_size,
12185                                           & new_size))
12186         section_size = new_size;
12187     }
12188
12189   if (relocate)
12190     {
12191       apply_relocations (file, section, start, section_size, NULL, NULL);
12192     }
12193   else
12194     {
12195       /* If the section being dumped has relocations against it the user might
12196          be expecting these relocations to have been applied.  Check for this
12197          case and issue a warning message in order to avoid confusion.
12198          FIXME: Maybe we ought to have an option that dumps a section with
12199          relocs applied ?  */
12200       for (relsec = section_headers;
12201            relsec < section_headers + elf_header.e_shnum;
12202            ++relsec)
12203         {
12204           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12205               || relsec->sh_info >= elf_header.e_shnum
12206               || section_headers + relsec->sh_info != section
12207               || relsec->sh_size == 0
12208               || relsec->sh_link >= elf_header.e_shnum)
12209             continue;
12210
12211           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12212           break;
12213         }
12214     }
12215
12216   addr = section->sh_addr;
12217   bytes = section_size;
12218   data = start;
12219
12220   while (bytes)
12221     {
12222       int j;
12223       int k;
12224       int lbytes;
12225
12226       lbytes = (bytes > 16 ? 16 : bytes);
12227
12228       printf ("  0x%8.8lx ", (unsigned long) addr);
12229
12230       for (j = 0; j < 16; j++)
12231         {
12232           if (j < lbytes)
12233             printf ("%2.2x", data[j]);
12234           else
12235             printf ("  ");
12236
12237           if ((j & 3) == 3)
12238             printf (" ");
12239         }
12240
12241       for (j = 0; j < lbytes; j++)
12242         {
12243           k = data[j];
12244           if (k >= ' ' && k < 0x7f)
12245             printf ("%c", k);
12246           else
12247             printf (".");
12248         }
12249
12250       putchar ('\n');
12251
12252       data  += lbytes;
12253       addr  += lbytes;
12254       bytes -= lbytes;
12255     }
12256
12257   free (real_start);
12258
12259   putchar ('\n');
12260 }
12261
12262 static int
12263 load_specific_debug_section (enum dwarf_section_display_enum debug,
12264                              const Elf_Internal_Shdr * sec, void * file)
12265 {
12266   struct dwarf_section * section = &debug_displays [debug].section;
12267   char buf [64];
12268
12269   /* If it is already loaded, do nothing.  */
12270   if (section->start != NULL)
12271     return 1;
12272
12273   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12274   section->address = sec->sh_addr;
12275   section->user_data = NULL;
12276   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12277                                                sec->sh_offset, 1,
12278                                                sec->sh_size, buf);
12279   if (section->start == NULL)
12280     section->size = 0;
12281   else
12282     {
12283       unsigned char *start = section->start;
12284       dwarf_size_type size = sec->sh_size;
12285       dwarf_size_type uncompressed_size = 0;
12286
12287       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12288         {
12289           Elf_Internal_Chdr chdr;
12290           unsigned int compression_header_size
12291             = get_compression_header (&chdr, start);
12292           if (chdr.ch_type != ELFCOMPRESS_ZLIB
12293               || chdr.ch_addralign != sec->sh_addralign)
12294             return 0;
12295           uncompressed_size = chdr.ch_size;
12296           start += compression_header_size;
12297           size -= compression_header_size;
12298         }
12299       else if (size > 12 && streq ((char *) start, "ZLIB"))
12300         {
12301           /* Read the zlib header.  In this case, it should be "ZLIB"
12302              followed by the uncompressed section size, 8 bytes in
12303              big-endian order.  */
12304           uncompressed_size = start[4]; uncompressed_size <<= 8;
12305           uncompressed_size += start[5]; uncompressed_size <<= 8;
12306           uncompressed_size += start[6]; uncompressed_size <<= 8;
12307           uncompressed_size += start[7]; uncompressed_size <<= 8;
12308           uncompressed_size += start[8]; uncompressed_size <<= 8;
12309           uncompressed_size += start[9]; uncompressed_size <<= 8;
12310           uncompressed_size += start[10]; uncompressed_size <<= 8;
12311           uncompressed_size += start[11];
12312           start += 12;
12313           size -= 12;
12314         }
12315
12316       if (uncompressed_size
12317           && uncompress_section_contents (&start, uncompressed_size,
12318                                           &size))
12319         {
12320           /* Free the compressed buffer, update the section buffer
12321              and the section size if uncompress is successful.  */
12322           free (section->start);
12323           section->start = start;
12324         }
12325       section->size = size;
12326     }
12327
12328   if (section->start == NULL)
12329     return 0;
12330
12331   if (debug_displays [debug].relocate)
12332     apply_relocations ((FILE *) file, sec, section->start, section->size,
12333                        & section->reloc_info, & section->num_relocs);
12334   else
12335     {
12336       section->reloc_info = NULL;
12337       section->num_relocs = 0;
12338     }
12339
12340   return 1;
12341 }
12342
12343 /* If this is not NULL, load_debug_section will only look for sections
12344    within the list of sections given here.  */
12345 unsigned int *section_subset = NULL;
12346
12347 int
12348 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12349 {
12350   struct dwarf_section * section = &debug_displays [debug].section;
12351   Elf_Internal_Shdr * sec;
12352
12353   /* Locate the debug section.  */
12354   sec = find_section_in_set (section->uncompressed_name, section_subset);
12355   if (sec != NULL)
12356     section->name = section->uncompressed_name;
12357   else
12358     {
12359       sec = find_section_in_set (section->compressed_name, section_subset);
12360       if (sec != NULL)
12361         section->name = section->compressed_name;
12362     }
12363   if (sec == NULL)
12364     return 0;
12365
12366   /* If we're loading from a subset of sections, and we've loaded
12367      a section matching this name before, it's likely that it's a
12368      different one.  */
12369   if (section_subset != NULL)
12370     free_debug_section (debug);
12371
12372   return load_specific_debug_section (debug, sec, (FILE *) file);
12373 }
12374
12375 void
12376 free_debug_section (enum dwarf_section_display_enum debug)
12377 {
12378   struct dwarf_section * section = &debug_displays [debug].section;
12379
12380   if (section->start == NULL)
12381     return;
12382
12383   free ((char *) section->start);
12384   section->start = NULL;
12385   section->address = 0;
12386   section->size = 0;
12387 }
12388
12389 static int
12390 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12391 {
12392   char * name = SECTION_NAME (section);
12393   const char * print_name = printable_section_name (section);
12394   bfd_size_type length;
12395   int result = 1;
12396   int i;
12397
12398   length = section->sh_size;
12399   if (length == 0)
12400     {
12401       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12402       return 0;
12403     }
12404   if (section->sh_type == SHT_NOBITS)
12405     {
12406       /* There is no point in dumping the contents of a debugging section
12407          which has the NOBITS type - the bits in the file will be random.
12408          This can happen when a file containing a .eh_frame section is
12409          stripped with the --only-keep-debug command line option.  */
12410       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12411               print_name);
12412       return 0;
12413     }
12414
12415   if (const_strneq (name, ".gnu.linkonce.wi."))
12416     name = ".debug_info";
12417
12418   /* See if we know how to display the contents of this section.  */
12419   for (i = 0; i < max; i++)
12420     if (streq (debug_displays[i].section.uncompressed_name, name)
12421         || (i == line && const_strneq (name, ".debug_line."))
12422         || streq (debug_displays[i].section.compressed_name, name))
12423       {
12424         struct dwarf_section * sec = &debug_displays [i].section;
12425         int secondary = (section != find_section (name));
12426
12427         if (secondary)
12428           free_debug_section ((enum dwarf_section_display_enum) i);
12429
12430         if (i == line && const_strneq (name, ".debug_line."))
12431           sec->name = name;
12432         else if (streq (sec->uncompressed_name, name))
12433           sec->name = sec->uncompressed_name;
12434         else
12435           sec->name = sec->compressed_name;
12436         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12437                                          section, file))
12438           {
12439             /* If this debug section is part of a CU/TU set in a .dwp file,
12440                restrict load_debug_section to the sections in that set.  */
12441             section_subset = find_cu_tu_set (file, shndx);
12442
12443             result &= debug_displays[i].display (sec, file);
12444
12445             section_subset = NULL;
12446
12447             if (secondary || (i != info && i != abbrev))
12448               free_debug_section ((enum dwarf_section_display_enum) i);
12449           }
12450
12451         break;
12452       }
12453
12454   if (i == max)
12455     {
12456       printf (_("Unrecognized debug section: %s\n"), print_name);
12457       result = 0;
12458     }
12459
12460   return result;
12461 }
12462
12463 /* Set DUMP_SECTS for all sections where dumps were requested
12464    based on section name.  */
12465
12466 static void
12467 initialise_dumps_byname (void)
12468 {
12469   struct dump_list_entry * cur;
12470
12471   for (cur = dump_sects_byname; cur; cur = cur->next)
12472     {
12473       unsigned int i;
12474       int any;
12475
12476       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12477         if (streq (SECTION_NAME (section_headers + i), cur->name))
12478           {
12479             request_dump_bynumber (i, cur->type);
12480             any = 1;
12481           }
12482
12483       if (!any)
12484         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12485               cur->name);
12486     }
12487 }
12488
12489 static void
12490 process_section_contents (FILE * file)
12491 {
12492   Elf_Internal_Shdr * section;
12493   unsigned int i;
12494
12495   if (! do_dump)
12496     return;
12497
12498   initialise_dumps_byname ();
12499
12500   for (i = 0, section = section_headers;
12501        i < elf_header.e_shnum && i < num_dump_sects;
12502        i++, section++)
12503     {
12504 #ifdef SUPPORT_DISASSEMBLY
12505       if (dump_sects[i] & DISASS_DUMP)
12506         disassemble_section (section, file);
12507 #endif
12508       if (dump_sects[i] & HEX_DUMP)
12509         dump_section_as_bytes (section, file, FALSE);
12510
12511       if (dump_sects[i] & RELOC_DUMP)
12512         dump_section_as_bytes (section, file, TRUE);
12513
12514       if (dump_sects[i] & STRING_DUMP)
12515         dump_section_as_strings (section, file);
12516
12517       if (dump_sects[i] & DEBUG_DUMP)
12518         display_debug_section (i, section, file);
12519     }
12520
12521   /* Check to see if the user requested a
12522      dump of a section that does not exist.  */
12523   while (i++ < num_dump_sects)
12524     if (dump_sects[i])
12525       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12526 }
12527
12528 static void
12529 process_mips_fpe_exception (int mask)
12530 {
12531   if (mask)
12532     {
12533       int first = 1;
12534       if (mask & OEX_FPU_INEX)
12535         fputs ("INEX", stdout), first = 0;
12536       if (mask & OEX_FPU_UFLO)
12537         printf ("%sUFLO", first ? "" : "|"), first = 0;
12538       if (mask & OEX_FPU_OFLO)
12539         printf ("%sOFLO", first ? "" : "|"), first = 0;
12540       if (mask & OEX_FPU_DIV0)
12541         printf ("%sDIV0", first ? "" : "|"), first = 0;
12542       if (mask & OEX_FPU_INVAL)
12543         printf ("%sINVAL", first ? "" : "|");
12544     }
12545   else
12546     fputs ("0", stdout);
12547 }
12548
12549 /* Display's the value of TAG at location P.  If TAG is
12550    greater than 0 it is assumed to be an unknown tag, and
12551    a message is printed to this effect.  Otherwise it is
12552    assumed that a message has already been printed.
12553
12554    If the bottom bit of TAG is set it assumed to have a
12555    string value, otherwise it is assumed to have an integer
12556    value.
12557
12558    Returns an updated P pointing to the first unread byte
12559    beyond the end of TAG's value.
12560
12561    Reads at or beyond END will not be made.  */
12562
12563 static unsigned char *
12564 display_tag_value (int tag,
12565                    unsigned char * p,
12566                    const unsigned char * const end)
12567 {
12568   unsigned long val;
12569
12570   if (tag > 0)
12571     printf ("  Tag_unknown_%d: ", tag);
12572
12573   if (p >= end)
12574     {
12575       warn (_("<corrupt tag>\n"));
12576     }
12577   else if (tag & 1)
12578     {
12579       /* PR 17531 file: 027-19978-0.004.  */
12580       size_t maxlen = (end - p) - 1;
12581
12582       putchar ('"');
12583       if (maxlen > 0)
12584         {
12585           print_symbol ((int) maxlen, (const char *) p);
12586           p += strnlen ((char *) p, maxlen) + 1;
12587         }
12588       else
12589         {
12590           printf (_("<corrupt string tag>"));
12591           p = (unsigned char *) end;
12592         }
12593       printf ("\"\n");
12594     }
12595   else
12596     {
12597       unsigned int len;
12598
12599       val = read_uleb128 (p, &len, end);
12600       p += len;
12601       printf ("%ld (0x%lx)\n", val, val);
12602     }
12603
12604   assert (p <= end);
12605   return p;
12606 }
12607
12608 /* ARM EABI attributes section.  */
12609 typedef struct
12610 {
12611   unsigned int tag;
12612   const char * name;
12613   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12614   unsigned int type;
12615   const char ** table;
12616 } arm_attr_public_tag;
12617
12618 static const char * arm_attr_tag_CPU_arch[] =
12619   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12620    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12621 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12622 static const char * arm_attr_tag_THUMB_ISA_use[] =
12623   {"No", "Thumb-1", "Thumb-2"};
12624 static const char * arm_attr_tag_FP_arch[] =
12625   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12626    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12627 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12628 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12629   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12630 static const char * arm_attr_tag_PCS_config[] =
12631   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12632    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12633 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12634   {"V6", "SB", "TLS", "Unused"};
12635 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12636   {"Absolute", "PC-relative", "SB-relative", "None"};
12637 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12638   {"Absolute", "PC-relative", "None"};
12639 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12640   {"None", "direct", "GOT-indirect"};
12641 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12642   {"None", "??? 1", "2", "??? 3", "4"};
12643 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12644 static const char * arm_attr_tag_ABI_FP_denormal[] =
12645   {"Unused", "Needed", "Sign only"};
12646 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12647 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12648 static const char * arm_attr_tag_ABI_FP_number_model[] =
12649   {"Unused", "Finite", "RTABI", "IEEE 754"};
12650 static const char * arm_attr_tag_ABI_enum_size[] =
12651   {"Unused", "small", "int", "forced to int"};
12652 static const char * arm_attr_tag_ABI_HardFP_use[] =
12653   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12654 static const char * arm_attr_tag_ABI_VFP_args[] =
12655   {"AAPCS", "VFP registers", "custom", "compatible"};
12656 static const char * arm_attr_tag_ABI_WMMX_args[] =
12657   {"AAPCS", "WMMX registers", "custom"};
12658 static const char * arm_attr_tag_ABI_optimization_goals[] =
12659   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12660     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12661 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12662   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12663     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12664 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12665 static const char * arm_attr_tag_FP_HP_extension[] =
12666   {"Not Allowed", "Allowed"};
12667 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12668   {"None", "IEEE 754", "Alternative Format"};
12669 static const char * arm_attr_tag_MPextension_use[] =
12670   {"Not Allowed", "Allowed"};
12671 static const char * arm_attr_tag_DIV_use[] =
12672   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12673     "Allowed in v7-A with integer division extension"};
12674 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12675 static const char * arm_attr_tag_Virtualization_use[] =
12676   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12677     "TrustZone and Virtualization Extensions"};
12678 static const char * arm_attr_tag_MPextension_use_legacy[] =
12679   {"Not Allowed", "Allowed"};
12680
12681 #define LOOKUP(id, name) \
12682   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12683 static arm_attr_public_tag arm_attr_public_tags[] =
12684 {
12685   {4, "CPU_raw_name", 1, NULL},
12686   {5, "CPU_name", 1, NULL},
12687   LOOKUP(6, CPU_arch),
12688   {7, "CPU_arch_profile", 0, NULL},
12689   LOOKUP(8, ARM_ISA_use),
12690   LOOKUP(9, THUMB_ISA_use),
12691   LOOKUP(10, FP_arch),
12692   LOOKUP(11, WMMX_arch),
12693   LOOKUP(12, Advanced_SIMD_arch),
12694   LOOKUP(13, PCS_config),
12695   LOOKUP(14, ABI_PCS_R9_use),
12696   LOOKUP(15, ABI_PCS_RW_data),
12697   LOOKUP(16, ABI_PCS_RO_data),
12698   LOOKUP(17, ABI_PCS_GOT_use),
12699   LOOKUP(18, ABI_PCS_wchar_t),
12700   LOOKUP(19, ABI_FP_rounding),
12701   LOOKUP(20, ABI_FP_denormal),
12702   LOOKUP(21, ABI_FP_exceptions),
12703   LOOKUP(22, ABI_FP_user_exceptions),
12704   LOOKUP(23, ABI_FP_number_model),
12705   {24, "ABI_align_needed", 0, NULL},
12706   {25, "ABI_align_preserved", 0, NULL},
12707   LOOKUP(26, ABI_enum_size),
12708   LOOKUP(27, ABI_HardFP_use),
12709   LOOKUP(28, ABI_VFP_args),
12710   LOOKUP(29, ABI_WMMX_args),
12711   LOOKUP(30, ABI_optimization_goals),
12712   LOOKUP(31, ABI_FP_optimization_goals),
12713   {32, "compatibility", 0, NULL},
12714   LOOKUP(34, CPU_unaligned_access),
12715   LOOKUP(36, FP_HP_extension),
12716   LOOKUP(38, ABI_FP_16bit_format),
12717   LOOKUP(42, MPextension_use),
12718   LOOKUP(44, DIV_use),
12719   {64, "nodefaults", 0, NULL},
12720   {65, "also_compatible_with", 0, NULL},
12721   LOOKUP(66, T2EE_use),
12722   {67, "conformance", 1, NULL},
12723   LOOKUP(68, Virtualization_use),
12724   LOOKUP(70, MPextension_use_legacy)
12725 };
12726 #undef LOOKUP
12727
12728 static unsigned char *
12729 display_arm_attribute (unsigned char * p,
12730                        const unsigned char * const end)
12731 {
12732   unsigned int tag;
12733   unsigned int len;
12734   unsigned int val;
12735   arm_attr_public_tag * attr;
12736   unsigned i;
12737   unsigned int type;
12738
12739   tag = read_uleb128 (p, &len, end);
12740   p += len;
12741   attr = NULL;
12742   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12743     {
12744       if (arm_attr_public_tags[i].tag == tag)
12745         {
12746           attr = &arm_attr_public_tags[i];
12747           break;
12748         }
12749     }
12750
12751   if (attr)
12752     {
12753       printf ("  Tag_%s: ", attr->name);
12754       switch (attr->type)
12755         {
12756         case 0:
12757           switch (tag)
12758             {
12759             case 7: /* Tag_CPU_arch_profile.  */
12760               val = read_uleb128 (p, &len, end);
12761               p += len;
12762               switch (val)
12763                 {
12764                 case 0: printf (_("None\n")); break;
12765                 case 'A': printf (_("Application\n")); break;
12766                 case 'R': printf (_("Realtime\n")); break;
12767                 case 'M': printf (_("Microcontroller\n")); break;
12768                 case 'S': printf (_("Application or Realtime\n")); break;
12769                 default: printf ("??? (%d)\n", val); break;
12770                 }
12771               break;
12772
12773             case 24: /* Tag_align_needed.  */
12774               val = read_uleb128 (p, &len, end);
12775               p += len;
12776               switch (val)
12777                 {
12778                 case 0: printf (_("None\n")); break;
12779                 case 1: printf (_("8-byte\n")); break;
12780                 case 2: printf (_("4-byte\n")); break;
12781                 case 3: printf ("??? 3\n"); break;
12782                 default:
12783                   if (val <= 12)
12784                     printf (_("8-byte and up to %d-byte extended\n"),
12785                             1 << val);
12786                   else
12787                     printf ("??? (%d)\n", val);
12788                   break;
12789                 }
12790               break;
12791
12792             case 25: /* Tag_align_preserved.  */
12793               val = read_uleb128 (p, &len, end);
12794               p += len;
12795               switch (val)
12796                 {
12797                 case 0: printf (_("None\n")); break;
12798                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12799                 case 2: printf (_("8-byte\n")); break;
12800                 case 3: printf ("??? 3\n"); break;
12801                 default:
12802                   if (val <= 12)
12803                     printf (_("8-byte and up to %d-byte extended\n"),
12804                             1 << val);
12805                   else
12806                     printf ("??? (%d)\n", val);
12807                   break;
12808                 }
12809               break;
12810
12811             case 32: /* Tag_compatibility.  */
12812               {
12813                 val = read_uleb128 (p, &len, end);
12814                 p += len;
12815                 printf (_("flag = %d, vendor = "), val);
12816                 if (p < end - 1)
12817                   {
12818                     size_t maxlen = (end - p) - 1;
12819
12820                     print_symbol ((int) maxlen, (const char *) p);
12821                     p += strnlen ((char *) p, maxlen) + 1;
12822                   }
12823                 else
12824                   {
12825                     printf (_("<corrupt>"));
12826                     p = (unsigned char *) end;
12827                   }
12828                 putchar ('\n');
12829               }
12830               break;
12831
12832             case 64: /* Tag_nodefaults.  */
12833               /* PR 17531: file: 001-505008-0.01.  */
12834               if (p < end)
12835                 p++;
12836               printf (_("True\n"));
12837               break;
12838
12839             case 65: /* Tag_also_compatible_with.  */
12840               val = read_uleb128 (p, &len, end);
12841               p += len;
12842               if (val == 6 /* Tag_CPU_arch.  */)
12843                 {
12844                   val = read_uleb128 (p, &len, end);
12845                   p += len;
12846                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12847                     printf ("??? (%d)\n", val);
12848                   else
12849                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12850                 }
12851               else
12852                 printf ("???\n");
12853               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12854                 ;
12855               break;
12856
12857             default:
12858               printf (_("<unknown: %d>\n"), tag);
12859               break;
12860             }
12861           return p;
12862
12863         case 1:
12864           return display_tag_value (-1, p, end);
12865         case 2:
12866           return display_tag_value (0, p, end);
12867
12868         default:
12869           assert (attr->type & 0x80);
12870           val = read_uleb128 (p, &len, end);
12871           p += len;
12872           type = attr->type & 0x7f;
12873           if (val >= type)
12874             printf ("??? (%d)\n", val);
12875           else
12876             printf ("%s\n", attr->table[val]);
12877           return p;
12878         }
12879     }
12880
12881   return display_tag_value (tag, p, end);
12882 }
12883
12884 static unsigned char *
12885 display_gnu_attribute (unsigned char * p,
12886                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12887                        const unsigned char * const end)
12888 {
12889   int tag;
12890   unsigned int len;
12891   int val;
12892
12893   tag = read_uleb128 (p, &len, end);
12894   p += len;
12895
12896   /* Tag_compatibility is the only generic GNU attribute defined at
12897      present.  */
12898   if (tag == 32)
12899     {
12900       val = read_uleb128 (p, &len, end);
12901       p += len;
12902
12903       printf (_("flag = %d, vendor = "), val);
12904       if (p == end)
12905         {
12906           printf (_("<corrupt>\n"));
12907           warn (_("corrupt vendor attribute\n"));
12908         }
12909       else
12910         {
12911           if (p < end - 1)
12912             {
12913               size_t maxlen = (end - p) - 1;
12914
12915               print_symbol ((int) maxlen, (const char *) p);
12916               p += strnlen ((char *) p, maxlen) + 1;
12917             }
12918           else
12919             {
12920               printf (_("<corrupt>"));
12921               p = (unsigned char *) end;
12922             }
12923           putchar ('\n');
12924         }
12925       return p;
12926     }
12927
12928   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12929     return display_proc_gnu_attribute (p, tag, end);
12930
12931   return display_tag_value (tag, p, end);
12932 }
12933
12934 static unsigned char *
12935 display_power_gnu_attribute (unsigned char * p,
12936                              int tag,
12937                              const unsigned char * const end)
12938 {
12939   unsigned int len;
12940   int val;
12941
12942   if (tag == Tag_GNU_Power_ABI_FP)
12943     {
12944       val = read_uleb128 (p, &len, end);
12945       p += len;
12946       printf ("  Tag_GNU_Power_ABI_FP: ");
12947
12948       switch (val)
12949         {
12950         case 0:
12951           printf (_("Hard or soft float\n"));
12952           break;
12953         case 1:
12954           printf (_("Hard float\n"));
12955           break;
12956         case 2:
12957           printf (_("Soft float\n"));
12958           break;
12959         case 3:
12960           printf (_("Single-precision hard float\n"));
12961           break;
12962         default:
12963           printf ("??? (%d)\n", val);
12964           break;
12965         }
12966       return p;
12967    }
12968
12969   if (tag == Tag_GNU_Power_ABI_Vector)
12970     {
12971       val = read_uleb128 (p, &len, end);
12972       p += len;
12973       printf ("  Tag_GNU_Power_ABI_Vector: ");
12974       switch (val)
12975         {
12976         case 0:
12977           printf (_("Any\n"));
12978           break;
12979         case 1:
12980           printf (_("Generic\n"));
12981           break;
12982         case 2:
12983           printf ("AltiVec\n");
12984           break;
12985         case 3:
12986           printf ("SPE\n");
12987           break;
12988         default:
12989           printf ("??? (%d)\n", val);
12990           break;
12991         }
12992       return p;
12993    }
12994
12995   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12996     {
12997       if (p == end)
12998         {
12999           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13000           return p;
13001         }
13002
13003       val = read_uleb128 (p, &len, end);
13004       p += len;
13005       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13006       switch (val)
13007        {
13008        case 0:
13009          printf (_("Any\n"));
13010          break;
13011        case 1:
13012          printf ("r3/r4\n");
13013          break;
13014        case 2:
13015          printf (_("Memory\n"));
13016          break;
13017        default:
13018          printf ("??? (%d)\n", val);
13019          break;
13020        }
13021       return p;
13022     }
13023
13024   return display_tag_value (tag & 1, p, end);
13025 }
13026
13027 static unsigned char *
13028 display_s390_gnu_attribute (unsigned char * p,
13029                             int tag,
13030                             const unsigned char * const end)
13031 {
13032   unsigned int len;
13033   int val;
13034
13035   if (tag == Tag_GNU_S390_ABI_Vector)
13036     {
13037       val = read_uleb128 (p, &len, end);
13038       p += len;
13039       printf ("  Tag_GNU_S390_ABI_Vector: ");
13040
13041       switch (val)
13042         {
13043         case 0:
13044           printf (_("any\n"));
13045           break;
13046         case 1:
13047           printf (_("software\n"));
13048           break;
13049         case 2:
13050           printf (_("hardware\n"));
13051           break;
13052         default:
13053           printf ("??? (%d)\n", val);
13054           break;
13055         }
13056       return p;
13057    }
13058
13059   return display_tag_value (tag & 1, p, end);
13060 }
13061
13062 static void
13063 display_sparc_hwcaps (int mask)
13064 {
13065   if (mask)
13066     {
13067       int first = 1;
13068
13069       if (mask & ELF_SPARC_HWCAP_MUL32)
13070         fputs ("mul32", stdout), first = 0;
13071       if (mask & ELF_SPARC_HWCAP_DIV32)
13072         printf ("%sdiv32", first ? "" : "|"), first = 0;
13073       if (mask & ELF_SPARC_HWCAP_FSMULD)
13074         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13075       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13076         printf ("%sv8plus", first ? "" : "|"), first = 0;
13077       if (mask & ELF_SPARC_HWCAP_POPC)
13078         printf ("%spopc", first ? "" : "|"), first = 0;
13079       if (mask & ELF_SPARC_HWCAP_VIS)
13080         printf ("%svis", first ? "" : "|"), first = 0;
13081       if (mask & ELF_SPARC_HWCAP_VIS2)
13082         printf ("%svis2", first ? "" : "|"), first = 0;
13083       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13084         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13085       if (mask & ELF_SPARC_HWCAP_FMAF)
13086         printf ("%sfmaf", first ? "" : "|"), first = 0;
13087       if (mask & ELF_SPARC_HWCAP_VIS3)
13088         printf ("%svis3", first ? "" : "|"), first = 0;
13089       if (mask & ELF_SPARC_HWCAP_HPC)
13090         printf ("%shpc", first ? "" : "|"), first = 0;
13091       if (mask & ELF_SPARC_HWCAP_RANDOM)
13092         printf ("%srandom", first ? "" : "|"), first = 0;
13093       if (mask & ELF_SPARC_HWCAP_TRANS)
13094         printf ("%strans", first ? "" : "|"), first = 0;
13095       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13096         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13097       if (mask & ELF_SPARC_HWCAP_IMA)
13098         printf ("%sima", first ? "" : "|"), first = 0;
13099       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13100         printf ("%scspare", first ? "" : "|"), first = 0;
13101     }
13102   else
13103     fputc ('0', stdout);
13104   fputc ('\n', stdout);
13105 }
13106
13107 static void
13108 display_sparc_hwcaps2 (int mask)
13109 {
13110   if (mask)
13111     {
13112       int first = 1;
13113
13114       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13115         fputs ("fjathplus", stdout), first = 0;
13116       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13117         printf ("%svis3b", first ? "" : "|"), first = 0;
13118       if (mask & ELF_SPARC_HWCAP2_ADP)
13119         printf ("%sadp", first ? "" : "|"), first = 0;
13120       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13121         printf ("%ssparc5", first ? "" : "|"), first = 0;
13122       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13123         printf ("%smwait", first ? "" : "|"), first = 0;
13124       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13125         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13126       if (mask & ELF_SPARC_HWCAP2_XMONT)
13127         printf ("%sxmont2", first ? "" : "|"), first = 0;
13128       if (mask & ELF_SPARC_HWCAP2_NSEC)
13129         printf ("%snsec", first ? "" : "|"), first = 0;
13130       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13131         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13132       if (mask & ELF_SPARC_HWCAP2_FJDES)
13133         printf ("%sfjdes", first ? "" : "|"), first = 0;
13134       if (mask & ELF_SPARC_HWCAP2_FJAES)
13135         printf ("%sfjaes", first ? "" : "|"), first = 0;
13136     }
13137   else
13138     fputc ('0', stdout);
13139   fputc ('\n', stdout);
13140 }
13141
13142 static unsigned char *
13143 display_sparc_gnu_attribute (unsigned char * p,
13144                              int tag,
13145                              const unsigned char * const end)
13146 {
13147   unsigned int len;
13148   int val;
13149
13150   if (tag == Tag_GNU_Sparc_HWCAPS)
13151     {
13152       val = read_uleb128 (p, &len, end);
13153       p += len;
13154       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13155       display_sparc_hwcaps (val);
13156       return p;
13157     }
13158   if (tag == Tag_GNU_Sparc_HWCAPS2)
13159     {
13160       val = read_uleb128 (p, &len, end);
13161       p += len;
13162       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13163       display_sparc_hwcaps2 (val);
13164       return p;
13165     }
13166
13167   return display_tag_value (tag, p, end);
13168 }
13169
13170 static void
13171 print_mips_fp_abi_value (int val)
13172 {
13173   switch (val)
13174     {
13175     case Val_GNU_MIPS_ABI_FP_ANY:
13176       printf (_("Hard or soft float\n"));
13177       break;
13178     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13179       printf (_("Hard float (double precision)\n"));
13180       break;
13181     case Val_GNU_MIPS_ABI_FP_SINGLE:
13182       printf (_("Hard float (single precision)\n"));
13183       break;
13184     case Val_GNU_MIPS_ABI_FP_SOFT:
13185       printf (_("Soft float\n"));
13186       break;
13187     case Val_GNU_MIPS_ABI_FP_OLD_64:
13188       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13189       break;
13190     case Val_GNU_MIPS_ABI_FP_XX:
13191       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13192       break;
13193     case Val_GNU_MIPS_ABI_FP_64:
13194       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13195       break;
13196     case Val_GNU_MIPS_ABI_FP_64A:
13197       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13198       break;
13199     default:
13200       printf ("??? (%d)\n", val);
13201       break;
13202     }
13203 }
13204
13205 static unsigned char *
13206 display_mips_gnu_attribute (unsigned char * p,
13207                             int tag,
13208                             const unsigned char * const end)
13209 {
13210   if (tag == Tag_GNU_MIPS_ABI_FP)
13211     {
13212       unsigned int len;
13213       int val;
13214
13215       val = read_uleb128 (p, &len, end);
13216       p += len;
13217       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13218
13219       print_mips_fp_abi_value (val);
13220
13221       return p;
13222    }
13223
13224   if (tag == Tag_GNU_MIPS_ABI_MSA)
13225     {
13226       unsigned int len;
13227       int val;
13228
13229       val = read_uleb128 (p, &len, end);
13230       p += len;
13231       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13232
13233       switch (val)
13234         {
13235         case Val_GNU_MIPS_ABI_MSA_ANY:
13236           printf (_("Any MSA or not\n"));
13237           break;
13238         case Val_GNU_MIPS_ABI_MSA_128:
13239           printf (_("128-bit MSA\n"));
13240           break;
13241         default:
13242           printf ("??? (%d)\n", val);
13243           break;
13244         }
13245       return p;
13246     }
13247
13248   return display_tag_value (tag & 1, p, end);
13249 }
13250
13251 static unsigned char *
13252 display_tic6x_attribute (unsigned char * p,
13253                          const unsigned char * const end)
13254 {
13255   int tag;
13256   unsigned int len;
13257   int val;
13258
13259   tag = read_uleb128 (p, &len, end);
13260   p += len;
13261
13262   switch (tag)
13263     {
13264     case Tag_ISA:
13265       val = read_uleb128 (p, &len, end);
13266       p += len;
13267       printf ("  Tag_ISA: ");
13268
13269       switch (val)
13270         {
13271         case C6XABI_Tag_ISA_none:
13272           printf (_("None\n"));
13273           break;
13274         case C6XABI_Tag_ISA_C62X:
13275           printf ("C62x\n");
13276           break;
13277         case C6XABI_Tag_ISA_C67X:
13278           printf ("C67x\n");
13279           break;
13280         case C6XABI_Tag_ISA_C67XP:
13281           printf ("C67x+\n");
13282           break;
13283         case C6XABI_Tag_ISA_C64X:
13284           printf ("C64x\n");
13285           break;
13286         case C6XABI_Tag_ISA_C64XP:
13287           printf ("C64x+\n");
13288           break;
13289         case C6XABI_Tag_ISA_C674X:
13290           printf ("C674x\n");
13291           break;
13292         default:
13293           printf ("??? (%d)\n", val);
13294           break;
13295         }
13296       return p;
13297
13298     case Tag_ABI_wchar_t:
13299       val = read_uleb128 (p, &len, end);
13300       p += len;
13301       printf ("  Tag_ABI_wchar_t: ");
13302       switch (val)
13303         {
13304         case 0:
13305           printf (_("Not used\n"));
13306           break;
13307         case 1:
13308           printf (_("2 bytes\n"));
13309           break;
13310         case 2:
13311           printf (_("4 bytes\n"));
13312           break;
13313         default:
13314           printf ("??? (%d)\n", val);
13315           break;
13316         }
13317       return p;
13318
13319     case Tag_ABI_stack_align_needed:
13320       val = read_uleb128 (p, &len, end);
13321       p += len;
13322       printf ("  Tag_ABI_stack_align_needed: ");
13323       switch (val)
13324         {
13325         case 0:
13326           printf (_("8-byte\n"));
13327           break;
13328         case 1:
13329           printf (_("16-byte\n"));
13330           break;
13331         default:
13332           printf ("??? (%d)\n", val);
13333           break;
13334         }
13335       return p;
13336
13337     case Tag_ABI_stack_align_preserved:
13338       val = read_uleb128 (p, &len, end);
13339       p += len;
13340       printf ("  Tag_ABI_stack_align_preserved: ");
13341       switch (val)
13342         {
13343         case 0:
13344           printf (_("8-byte\n"));
13345           break;
13346         case 1:
13347           printf (_("16-byte\n"));
13348           break;
13349         default:
13350           printf ("??? (%d)\n", val);
13351           break;
13352         }
13353       return p;
13354
13355     case Tag_ABI_DSBT:
13356       val = read_uleb128 (p, &len, end);
13357       p += len;
13358       printf ("  Tag_ABI_DSBT: ");
13359       switch (val)
13360         {
13361         case 0:
13362           printf (_("DSBT addressing not used\n"));
13363           break;
13364         case 1:
13365           printf (_("DSBT addressing used\n"));
13366           break;
13367         default:
13368           printf ("??? (%d)\n", val);
13369           break;
13370         }
13371       return p;
13372
13373     case Tag_ABI_PID:
13374       val = read_uleb128 (p, &len, end);
13375       p += len;
13376       printf ("  Tag_ABI_PID: ");
13377       switch (val)
13378         {
13379         case 0:
13380           printf (_("Data addressing position-dependent\n"));
13381           break;
13382         case 1:
13383           printf (_("Data addressing position-independent, GOT near DP\n"));
13384           break;
13385         case 2:
13386           printf (_("Data addressing position-independent, GOT far from DP\n"));
13387           break;
13388         default:
13389           printf ("??? (%d)\n", val);
13390           break;
13391         }
13392       return p;
13393
13394     case Tag_ABI_PIC:
13395       val = read_uleb128 (p, &len, end);
13396       p += len;
13397       printf ("  Tag_ABI_PIC: ");
13398       switch (val)
13399         {
13400         case 0:
13401           printf (_("Code addressing position-dependent\n"));
13402           break;
13403         case 1:
13404           printf (_("Code addressing position-independent\n"));
13405           break;
13406         default:
13407           printf ("??? (%d)\n", val);
13408           break;
13409         }
13410       return p;
13411
13412     case Tag_ABI_array_object_alignment:
13413       val = read_uleb128 (p, &len, end);
13414       p += len;
13415       printf ("  Tag_ABI_array_object_alignment: ");
13416       switch (val)
13417         {
13418         case 0:
13419           printf (_("8-byte\n"));
13420           break;
13421         case 1:
13422           printf (_("4-byte\n"));
13423           break;
13424         case 2:
13425           printf (_("16-byte\n"));
13426           break;
13427         default:
13428           printf ("??? (%d)\n", val);
13429           break;
13430         }
13431       return p;
13432
13433     case Tag_ABI_array_object_align_expected:
13434       val = read_uleb128 (p, &len, end);
13435       p += len;
13436       printf ("  Tag_ABI_array_object_align_expected: ");
13437       switch (val)
13438         {
13439         case 0:
13440           printf (_("8-byte\n"));
13441           break;
13442         case 1:
13443           printf (_("4-byte\n"));
13444           break;
13445         case 2:
13446           printf (_("16-byte\n"));
13447           break;
13448         default:
13449           printf ("??? (%d)\n", val);
13450           break;
13451         }
13452       return p;
13453
13454     case Tag_ABI_compatibility:
13455       {
13456         val = read_uleb128 (p, &len, end);
13457         p += len;
13458         printf ("  Tag_ABI_compatibility: ");
13459         printf (_("flag = %d, vendor = "), val);
13460         if (p < end - 1)
13461           {
13462             size_t maxlen = (end - p) - 1;
13463
13464             print_symbol ((int) maxlen, (const char *) p);
13465             p += strnlen ((char *) p, maxlen) + 1;
13466           }
13467         else
13468           {
13469             printf (_("<corrupt>"));
13470             p = (unsigned char *) end;
13471           }
13472         putchar ('\n');
13473         return p;
13474       }
13475
13476     case Tag_ABI_conformance:
13477       {
13478         printf ("  Tag_ABI_conformance: \"");
13479         if (p < end - 1)
13480           {
13481             size_t maxlen = (end - p) - 1;
13482
13483             print_symbol ((int) maxlen, (const char *) p);
13484             p += strnlen ((char *) p, maxlen) + 1;
13485           }
13486         else
13487           {
13488             printf (_("<corrupt>"));
13489             p = (unsigned char *) end;
13490           }
13491         printf ("\"\n");
13492         return p;
13493       }
13494     }
13495
13496   return display_tag_value (tag, p, end);
13497 }
13498
13499 static void
13500 display_raw_attribute (unsigned char * p, unsigned char * end)
13501 {
13502   unsigned long addr = 0;
13503   size_t bytes = end - p;
13504
13505   assert (end > p);
13506   while (bytes)
13507     {
13508       int j;
13509       int k;
13510       int lbytes = (bytes > 16 ? 16 : bytes);
13511
13512       printf ("  0x%8.8lx ", addr);
13513
13514       for (j = 0; j < 16; j++)
13515         {
13516           if (j < lbytes)
13517             printf ("%2.2x", p[j]);
13518           else
13519             printf ("  ");
13520
13521           if ((j & 3) == 3)
13522             printf (" ");
13523         }
13524
13525       for (j = 0; j < lbytes; j++)
13526         {
13527           k = p[j];
13528           if (k >= ' ' && k < 0x7f)
13529             printf ("%c", k);
13530           else
13531             printf (".");
13532         }
13533
13534       putchar ('\n');
13535
13536       p  += lbytes;
13537       bytes -= lbytes;
13538       addr += lbytes;
13539     }
13540
13541   putchar ('\n');
13542 }
13543
13544 static unsigned char *
13545 display_msp430x_attribute (unsigned char * p,
13546                            const unsigned char * const end)
13547 {
13548   unsigned int len;
13549   int val;
13550   int tag;
13551
13552   tag = read_uleb128 (p, & len, end);
13553   p += len;
13554
13555   switch (tag)
13556     {
13557     case OFBA_MSPABI_Tag_ISA:
13558       val = read_uleb128 (p, &len, end);
13559       p += len;
13560       printf ("  Tag_ISA: ");
13561       switch (val)
13562         {
13563         case 0: printf (_("None\n")); break;
13564         case 1: printf (_("MSP430\n")); break;
13565         case 2: printf (_("MSP430X\n")); break;
13566         default: printf ("??? (%d)\n", val); break;
13567         }
13568       break;
13569
13570     case OFBA_MSPABI_Tag_Code_Model:
13571       val = read_uleb128 (p, &len, end);
13572       p += len;
13573       printf ("  Tag_Code_Model: ");
13574       switch (val)
13575         {
13576         case 0: printf (_("None\n")); break;
13577         case 1: printf (_("Small\n")); break;
13578         case 2: printf (_("Large\n")); break;
13579         default: printf ("??? (%d)\n", val); break;
13580         }
13581       break;
13582
13583     case OFBA_MSPABI_Tag_Data_Model:
13584       val = read_uleb128 (p, &len, end);
13585       p += len;
13586       printf ("  Tag_Data_Model: ");
13587       switch (val)
13588         {
13589         case 0: printf (_("None\n")); break;
13590         case 1: printf (_("Small\n")); break;
13591         case 2: printf (_("Large\n")); break;
13592         case 3: printf (_("Restricted Large\n")); break;
13593         default: printf ("??? (%d)\n", val); break;
13594         }
13595       break;
13596
13597     default:
13598       printf (_("  <unknown tag %d>: "), tag);
13599
13600       if (tag & 1)
13601         {
13602           putchar ('"');
13603           if (p < end - 1)
13604             {
13605               size_t maxlen = (end - p) - 1;
13606
13607               print_symbol ((int) maxlen, (const char *) p);
13608               p += strnlen ((char *) p, maxlen) + 1;
13609             }
13610           else
13611             {
13612               printf (_("<corrupt>"));
13613               p = (unsigned char *) end;
13614             }
13615           printf ("\"\n");
13616         }
13617       else
13618         {
13619           val = read_uleb128 (p, &len, end);
13620           p += len;
13621           printf ("%d (0x%x)\n", val, val);
13622         }
13623       break;
13624    }
13625
13626   assert (p <= end);
13627   return p;
13628 }
13629
13630 static int
13631 process_attributes (FILE * file,
13632                     const char * public_name,
13633                     unsigned int proc_type,
13634                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13635                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13636 {
13637   Elf_Internal_Shdr * sect;
13638   unsigned i;
13639
13640   /* Find the section header so that we get the size.  */
13641   for (i = 0, sect = section_headers;
13642        i < elf_header.e_shnum;
13643        i++, sect++)
13644     {
13645       unsigned char * contents;
13646       unsigned char * p;
13647
13648       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13649         continue;
13650
13651       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13652                                              sect->sh_size, _("attributes"));
13653       if (contents == NULL)
13654         continue;
13655
13656       p = contents;
13657       if (*p == 'A')
13658         {
13659           bfd_vma section_len;
13660
13661           section_len = sect->sh_size - 1;
13662           p++;
13663
13664           while (section_len > 0)
13665             {
13666               bfd_vma attr_len;
13667               unsigned int namelen;
13668               bfd_boolean public_section;
13669               bfd_boolean gnu_section;
13670
13671               if (section_len <= 4)
13672                 {
13673                   error (_("Tag section ends prematurely\n"));
13674                   break;
13675                 }
13676               attr_len = byte_get (p, 4);
13677               p += 4;
13678
13679               if (attr_len > section_len)
13680                 {
13681                   error (_("Bad attribute length (%u > %u)\n"),
13682                           (unsigned) attr_len, (unsigned) section_len);
13683                   attr_len = section_len;
13684                 }
13685               /* PR 17531: file: 001-101425-0.004  */
13686               else if (attr_len < 5)
13687                 {
13688                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13689                   break;
13690                 }
13691
13692               section_len -= attr_len;
13693               attr_len -= 4;
13694
13695               namelen = strnlen ((char *) p, attr_len) + 1;
13696               if (namelen == 0 || namelen >= attr_len)
13697                 {
13698                   error (_("Corrupt attribute section name\n"));
13699                   break;
13700                 }
13701
13702               printf (_("Attribute Section: "));
13703               print_symbol (INT_MAX, (const char *) p);
13704               putchar ('\n');
13705
13706               if (public_name && streq ((char *) p, public_name))
13707                 public_section = TRUE;
13708               else
13709                 public_section = FALSE;
13710
13711               if (streq ((char *) p, "gnu"))
13712                 gnu_section = TRUE;
13713               else
13714                 gnu_section = FALSE;
13715
13716               p += namelen;
13717               attr_len -= namelen;
13718
13719               while (attr_len > 0 && p < contents + sect->sh_size)
13720                 {
13721                   int tag;
13722                   int val;
13723                   bfd_vma size;
13724                   unsigned char * end;
13725
13726                   /* PR binutils/17531: Safe handling of corrupt files.  */
13727                   if (attr_len < 6)
13728                     {
13729                       error (_("Unused bytes at end of section\n"));
13730                       section_len = 0;
13731                       break;
13732                     }
13733
13734                   tag = *(p++);
13735                   size = byte_get (p, 4);
13736                   if (size > attr_len)
13737                     {
13738                       error (_("Bad subsection length (%u > %u)\n"),
13739                               (unsigned) size, (unsigned) attr_len);
13740                       size = attr_len;
13741                     }
13742                   /* PR binutils/17531: Safe handling of corrupt files.  */
13743                   if (size < 6)
13744                     {
13745                       error (_("Bad subsection length (%u < 6)\n"),
13746                               (unsigned) size);
13747                       section_len = 0;
13748                       break;
13749                     }
13750
13751                   attr_len -= size;
13752                   end = p + size - 1;
13753                   assert (end <= contents + sect->sh_size);
13754                   p += 4;
13755
13756                   switch (tag)
13757                     {
13758                     case 1:
13759                       printf (_("File Attributes\n"));
13760                       break;
13761                     case 2:
13762                       printf (_("Section Attributes:"));
13763                       goto do_numlist;
13764                     case 3:
13765                       printf (_("Symbol Attributes:"));
13766                     do_numlist:
13767                       for (;;)
13768                         {
13769                           unsigned int j;
13770
13771                           val = read_uleb128 (p, &j, end);
13772                           p += j;
13773                           if (val == 0)
13774                             break;
13775                           printf (" %d", val);
13776                         }
13777                       printf ("\n");
13778                       break;
13779                     default:
13780                       printf (_("Unknown tag: %d\n"), tag);
13781                       public_section = FALSE;
13782                       break;
13783                     }
13784
13785                   if (public_section && display_pub_attribute != NULL)
13786                     {
13787                       while (p < end)
13788                         p = display_pub_attribute (p, end);
13789                       assert (p <= end);
13790                     }
13791                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13792                     {
13793                       while (p < end)
13794                         p = display_gnu_attribute (p,
13795                                                    display_proc_gnu_attribute,
13796                                                    end);
13797                       assert (p <= end);
13798                     }
13799                   else if (p < end)
13800                     {
13801                       printf (_("  Unknown attribute:\n"));
13802                       display_raw_attribute (p, end);
13803                       p = end;
13804                     }
13805                   else
13806                     attr_len = 0;
13807                 }
13808             }
13809         }
13810       else
13811         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13812
13813       free (contents);
13814     }
13815   return 1;
13816 }
13817
13818 static int
13819 process_arm_specific (FILE * file)
13820 {
13821   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13822                              display_arm_attribute, NULL);
13823 }
13824
13825 static int
13826 process_power_specific (FILE * file)
13827 {
13828   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13829                              display_power_gnu_attribute);
13830 }
13831
13832 static int
13833 process_s390_specific (FILE * file)
13834 {
13835   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13836                              display_s390_gnu_attribute);
13837 }
13838
13839 static int
13840 process_sparc_specific (FILE * file)
13841 {
13842   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13843                              display_sparc_gnu_attribute);
13844 }
13845
13846 static int
13847 process_tic6x_specific (FILE * file)
13848 {
13849   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13850                              display_tic6x_attribute, NULL);
13851 }
13852
13853 static int
13854 process_msp430x_specific (FILE * file)
13855 {
13856   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13857                              display_msp430x_attribute, NULL);
13858 }
13859
13860 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13861    Print the Address, Access and Initial fields of an entry at VMA ADDR
13862    and return the VMA of the next entry, or -1 if there was a problem.
13863    Does not read from DATA_END or beyond.  */
13864
13865 static bfd_vma
13866 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13867                       unsigned char * data_end)
13868 {
13869   printf ("  ");
13870   print_vma (addr, LONG_HEX);
13871   printf (" ");
13872   if (addr < pltgot + 0xfff0)
13873     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13874   else
13875     printf ("%10s", "");
13876   printf (" ");
13877   if (data == NULL)
13878     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13879   else
13880     {
13881       bfd_vma entry;
13882       unsigned char * from = data + addr - pltgot;
13883
13884       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13885         {
13886           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13887           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13888           return (bfd_vma) -1;
13889         }
13890       else
13891         {
13892           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13893           print_vma (entry, LONG_HEX);
13894         }
13895     }
13896   return addr + (is_32bit_elf ? 4 : 8);
13897 }
13898
13899 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13900    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13901    ADDR and return the VMA of the next entry.  */
13902
13903 static bfd_vma
13904 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13905 {
13906   printf ("  ");
13907   print_vma (addr, LONG_HEX);
13908   printf (" ");
13909   if (data == NULL)
13910     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13911   else
13912     {
13913       bfd_vma entry;
13914
13915       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13916       print_vma (entry, LONG_HEX);
13917     }
13918   return addr + (is_32bit_elf ? 4 : 8);
13919 }
13920
13921 static void
13922 print_mips_ases (unsigned int mask)
13923 {
13924   if (mask & AFL_ASE_DSP)
13925     fputs ("\n\tDSP ASE", stdout);
13926   if (mask & AFL_ASE_DSPR2)
13927     fputs ("\n\tDSP R2 ASE", stdout);
13928   if (mask & AFL_ASE_EVA)
13929     fputs ("\n\tEnhanced VA Scheme", stdout);
13930   if (mask & AFL_ASE_MCU)
13931     fputs ("\n\tMCU (MicroController) ASE", stdout);
13932   if (mask & AFL_ASE_MDMX)
13933     fputs ("\n\tMDMX ASE", stdout);
13934   if (mask & AFL_ASE_MIPS3D)
13935     fputs ("\n\tMIPS-3D ASE", stdout);
13936   if (mask & AFL_ASE_MT)
13937     fputs ("\n\tMT ASE", stdout);
13938   if (mask & AFL_ASE_SMARTMIPS)
13939     fputs ("\n\tSmartMIPS ASE", stdout);
13940   if (mask & AFL_ASE_VIRT)
13941     fputs ("\n\tVZ ASE", stdout);
13942   if (mask & AFL_ASE_MSA)
13943     fputs ("\n\tMSA ASE", stdout);
13944   if (mask & AFL_ASE_MIPS16)
13945     fputs ("\n\tMIPS16 ASE", stdout);
13946   if (mask & AFL_ASE_MICROMIPS)
13947     fputs ("\n\tMICROMIPS ASE", stdout);
13948   if (mask & AFL_ASE_XPA)
13949     fputs ("\n\tXPA ASE", stdout);
13950   if (mask == 0)
13951     fprintf (stdout, "\n\t%s", _("None"));
13952   else if ((mask & ~AFL_ASE_MASK) != 0)
13953     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13954 }
13955
13956 static void
13957 print_mips_isa_ext (unsigned int isa_ext)
13958 {
13959   switch (isa_ext)
13960     {
13961     case 0:
13962       fputs (_("None"), stdout);
13963       break;
13964     case AFL_EXT_XLR:
13965       fputs ("RMI XLR", stdout);
13966       break;
13967     case AFL_EXT_OCTEON3:
13968       fputs ("Cavium Networks Octeon3", stdout);
13969       break;
13970     case AFL_EXT_OCTEON2:
13971       fputs ("Cavium Networks Octeon2", stdout);
13972       break;
13973     case AFL_EXT_OCTEONP:
13974       fputs ("Cavium Networks OcteonP", stdout);
13975       break;
13976     case AFL_EXT_LOONGSON_3A:
13977       fputs ("Loongson 3A", stdout);
13978       break;
13979     case AFL_EXT_OCTEON:
13980       fputs ("Cavium Networks Octeon", stdout);
13981       break;
13982     case AFL_EXT_5900:
13983       fputs ("Toshiba R5900", stdout);
13984       break;
13985     case AFL_EXT_4650:
13986       fputs ("MIPS R4650", stdout);
13987       break;
13988     case AFL_EXT_4010:
13989       fputs ("LSI R4010", stdout);
13990       break;
13991     case AFL_EXT_4100:
13992       fputs ("NEC VR4100", stdout);
13993       break;
13994     case AFL_EXT_3900:
13995       fputs ("Toshiba R3900", stdout);
13996       break;
13997     case AFL_EXT_10000:
13998       fputs ("MIPS R10000", stdout);
13999       break;
14000     case AFL_EXT_SB1:
14001       fputs ("Broadcom SB-1", stdout);
14002       break;
14003     case AFL_EXT_4111:
14004       fputs ("NEC VR4111/VR4181", stdout);
14005       break;
14006     case AFL_EXT_4120:
14007       fputs ("NEC VR4120", stdout);
14008       break;
14009     case AFL_EXT_5400:
14010       fputs ("NEC VR5400", stdout);
14011       break;
14012     case AFL_EXT_5500:
14013       fputs ("NEC VR5500", stdout);
14014       break;
14015     case AFL_EXT_LOONGSON_2E:
14016       fputs ("ST Microelectronics Loongson 2E", stdout);
14017       break;
14018     case AFL_EXT_LOONGSON_2F:
14019       fputs ("ST Microelectronics Loongson 2F", stdout);
14020       break;
14021     default:
14022       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14023     }
14024 }
14025
14026 static int
14027 get_mips_reg_size (int reg_size)
14028 {
14029   return (reg_size == AFL_REG_NONE) ? 0
14030          : (reg_size == AFL_REG_32) ? 32
14031          : (reg_size == AFL_REG_64) ? 64
14032          : (reg_size == AFL_REG_128) ? 128
14033          : -1;
14034 }
14035
14036 static int
14037 process_mips_specific (FILE * file)
14038 {
14039   Elf_Internal_Dyn * entry;
14040   Elf_Internal_Shdr *sect = NULL;
14041   size_t liblist_offset = 0;
14042   size_t liblistno = 0;
14043   size_t conflictsno = 0;
14044   size_t options_offset = 0;
14045   size_t conflicts_offset = 0;
14046   size_t pltrelsz = 0;
14047   size_t pltrel = 0;
14048   bfd_vma pltgot = 0;
14049   bfd_vma mips_pltgot = 0;
14050   bfd_vma jmprel = 0;
14051   bfd_vma local_gotno = 0;
14052   bfd_vma gotsym = 0;
14053   bfd_vma symtabno = 0;
14054
14055   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14056                       display_mips_gnu_attribute);
14057
14058   sect = find_section (".MIPS.abiflags");
14059
14060   if (sect != NULL)
14061     {
14062       Elf_External_ABIFlags_v0 *abiflags_ext;
14063       Elf_Internal_ABIFlags_v0 abiflags_in;
14064
14065       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14066         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14067       else
14068         {
14069           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14070                                    sect->sh_size, _("MIPS ABI Flags section"));
14071           if (abiflags_ext)
14072             {
14073               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14074               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14075               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14076               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14077               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14078               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14079               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14080               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14081               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14082               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14083               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14084
14085               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14086               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14087               if (abiflags_in.isa_rev > 1)
14088                 printf ("r%d", abiflags_in.isa_rev);
14089               printf ("\nGPR size: %d",
14090                       get_mips_reg_size (abiflags_in.gpr_size));
14091               printf ("\nCPR1 size: %d",
14092                       get_mips_reg_size (abiflags_in.cpr1_size));
14093               printf ("\nCPR2 size: %d",
14094                       get_mips_reg_size (abiflags_in.cpr2_size));
14095               fputs ("\nFP ABI: ", stdout);
14096               print_mips_fp_abi_value (abiflags_in.fp_abi);
14097               fputs ("ISA Extension: ", stdout);
14098               print_mips_isa_ext (abiflags_in.isa_ext);
14099               fputs ("\nASEs:", stdout);
14100               print_mips_ases (abiflags_in.ases);
14101               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14102               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14103               fputc ('\n', stdout);
14104               free (abiflags_ext);
14105             }
14106         }
14107     }
14108
14109   /* We have a lot of special sections.  Thanks SGI!  */
14110   if (dynamic_section == NULL)
14111     /* No information available.  */
14112     return 0;
14113
14114   for (entry = dynamic_section;
14115        /* PR 17531 file: 012-50589-0.004.  */
14116        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14117        ++entry)
14118     switch (entry->d_tag)
14119       {
14120       case DT_MIPS_LIBLIST:
14121         liblist_offset
14122           = offset_from_vma (file, entry->d_un.d_val,
14123                              liblistno * sizeof (Elf32_External_Lib));
14124         break;
14125       case DT_MIPS_LIBLISTNO:
14126         liblistno = entry->d_un.d_val;
14127         break;
14128       case DT_MIPS_OPTIONS:
14129         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14130         break;
14131       case DT_MIPS_CONFLICT:
14132         conflicts_offset
14133           = offset_from_vma (file, entry->d_un.d_val,
14134                              conflictsno * sizeof (Elf32_External_Conflict));
14135         break;
14136       case DT_MIPS_CONFLICTNO:
14137         conflictsno = entry->d_un.d_val;
14138         break;
14139       case DT_PLTGOT:
14140         pltgot = entry->d_un.d_ptr;
14141         break;
14142       case DT_MIPS_LOCAL_GOTNO:
14143         local_gotno = entry->d_un.d_val;
14144         break;
14145       case DT_MIPS_GOTSYM:
14146         gotsym = entry->d_un.d_val;
14147         break;
14148       case DT_MIPS_SYMTABNO:
14149         symtabno = entry->d_un.d_val;
14150         break;
14151       case DT_MIPS_PLTGOT:
14152         mips_pltgot = entry->d_un.d_ptr;
14153         break;
14154       case DT_PLTREL:
14155         pltrel = entry->d_un.d_val;
14156         break;
14157       case DT_PLTRELSZ:
14158         pltrelsz = entry->d_un.d_val;
14159         break;
14160       case DT_JMPREL:
14161         jmprel = entry->d_un.d_ptr;
14162         break;
14163       default:
14164         break;
14165       }
14166
14167   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14168     {
14169       Elf32_External_Lib * elib;
14170       size_t cnt;
14171
14172       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14173                                               liblistno,
14174                                               sizeof (Elf32_External_Lib),
14175                                               _("liblist section data"));
14176       if (elib)
14177         {
14178           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14179                   (unsigned long) liblistno);
14180           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14181                  stdout);
14182
14183           for (cnt = 0; cnt < liblistno; ++cnt)
14184             {
14185               Elf32_Lib liblist;
14186               time_t atime;
14187               char timebuf[20];
14188               struct tm * tmp;
14189
14190               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14191               atime = BYTE_GET (elib[cnt].l_time_stamp);
14192               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14193               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14194               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14195
14196               tmp = gmtime (&atime);
14197               snprintf (timebuf, sizeof (timebuf),
14198                         "%04u-%02u-%02uT%02u:%02u:%02u",
14199                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14200                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14201
14202               printf ("%3lu: ", (unsigned long) cnt);
14203               if (VALID_DYNAMIC_NAME (liblist.l_name))
14204                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14205               else
14206                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14207               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14208                       liblist.l_version);
14209
14210               if (liblist.l_flags == 0)
14211                 puts (_(" NONE"));
14212               else
14213                 {
14214                   static const struct
14215                   {
14216                     const char * name;
14217                     int bit;
14218                   }
14219                   l_flags_vals[] =
14220                   {
14221                     { " EXACT_MATCH", LL_EXACT_MATCH },
14222                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14223                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14224                     { " EXPORTS", LL_EXPORTS },
14225                     { " DELAY_LOAD", LL_DELAY_LOAD },
14226                     { " DELTA", LL_DELTA }
14227                   };
14228                   int flags = liblist.l_flags;
14229                   size_t fcnt;
14230
14231                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14232                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14233                       {
14234                         fputs (l_flags_vals[fcnt].name, stdout);
14235                         flags ^= l_flags_vals[fcnt].bit;
14236                       }
14237                   if (flags != 0)
14238                     printf (" %#x", (unsigned int) flags);
14239
14240                   puts ("");
14241                 }
14242             }
14243
14244           free (elib);
14245         }
14246     }
14247
14248   if (options_offset != 0)
14249     {
14250       Elf_External_Options * eopt;
14251       Elf_Internal_Options * iopt;
14252       Elf_Internal_Options * option;
14253       size_t offset;
14254       int cnt;
14255       sect = section_headers;
14256
14257       /* Find the section header so that we get the size.  */
14258       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14259       /* PR 17533 file: 012-277276-0.004.  */
14260       if (sect == NULL)
14261         {
14262           error (_("No MIPS_OPTIONS header found\n"));
14263           return 0;
14264         }
14265
14266       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14267                                                 sect->sh_size, _("options"));
14268       if (eopt)
14269         {
14270           iopt = (Elf_Internal_Options *)
14271               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14272           if (iopt == NULL)
14273             {
14274               error (_("Out of memory allocatinf space for MIPS options\n"));
14275               return 0;
14276             }
14277
14278           offset = cnt = 0;
14279           option = iopt;
14280
14281           while (offset <= sect->sh_size - sizeof (* eopt))
14282             {
14283               Elf_External_Options * eoption;
14284
14285               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14286
14287               option->kind = BYTE_GET (eoption->kind);
14288               option->size = BYTE_GET (eoption->size);
14289               option->section = BYTE_GET (eoption->section);
14290               option->info = BYTE_GET (eoption->info);
14291
14292               /* PR 17531: file: ffa0fa3b.  */
14293               if (option->size < sizeof (* eopt)
14294                   || offset + option->size > sect->sh_size)
14295                 {
14296                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14297                   return 0;
14298                 }
14299               offset += option->size;
14300
14301               ++option;
14302               ++cnt;
14303             }
14304
14305           printf (_("\nSection '%s' contains %d entries:\n"),
14306                   printable_section_name (sect), cnt);
14307
14308           option = iopt;
14309           offset = 0;
14310
14311           while (cnt-- > 0)
14312             {
14313               size_t len;
14314
14315               switch (option->kind)
14316                 {
14317                 case ODK_NULL:
14318                   /* This shouldn't happen.  */
14319                   printf (" NULL       %d %lx", option->section, option->info);
14320                   break;
14321                 case ODK_REGINFO:
14322                   printf (" REGINFO    ");
14323                   if (elf_header.e_machine == EM_MIPS)
14324                     {
14325                       /* 32bit form.  */
14326                       Elf32_External_RegInfo * ereg;
14327                       Elf32_RegInfo reginfo;
14328
14329                       ereg = (Elf32_External_RegInfo *) (option + 1);
14330                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14331                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14332                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14333                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14334                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14335                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14336
14337                       printf ("GPR %08lx  GP 0x%lx\n",
14338                               reginfo.ri_gprmask,
14339                               (unsigned long) reginfo.ri_gp_value);
14340                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14341                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14342                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14343                     }
14344                   else
14345                     {
14346                       /* 64 bit form.  */
14347                       Elf64_External_RegInfo * ereg;
14348                       Elf64_Internal_RegInfo reginfo;
14349
14350                       ereg = (Elf64_External_RegInfo *) (option + 1);
14351                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14352                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14353                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14354                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14355                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14356                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14357
14358                       printf ("GPR %08lx  GP 0x",
14359                               reginfo.ri_gprmask);
14360                       printf_vma (reginfo.ri_gp_value);
14361                       printf ("\n");
14362
14363                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14364                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14365                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14366                     }
14367                   ++option;
14368                   continue;
14369                 case ODK_EXCEPTIONS:
14370                   fputs (" EXCEPTIONS fpe_min(", stdout);
14371                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14372                   fputs (") fpe_max(", stdout);
14373                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14374                   fputs (")", stdout);
14375
14376                   if (option->info & OEX_PAGE0)
14377                     fputs (" PAGE0", stdout);
14378                   if (option->info & OEX_SMM)
14379                     fputs (" SMM", stdout);
14380                   if (option->info & OEX_FPDBUG)
14381                     fputs (" FPDBUG", stdout);
14382                   if (option->info & OEX_DISMISS)
14383                     fputs (" DISMISS", stdout);
14384                   break;
14385                 case ODK_PAD:
14386                   fputs (" PAD       ", stdout);
14387                   if (option->info & OPAD_PREFIX)
14388                     fputs (" PREFIX", stdout);
14389                   if (option->info & OPAD_POSTFIX)
14390                     fputs (" POSTFIX", stdout);
14391                   if (option->info & OPAD_SYMBOL)
14392                     fputs (" SYMBOL", stdout);
14393                   break;
14394                 case ODK_HWPATCH:
14395                   fputs (" HWPATCH   ", stdout);
14396                   if (option->info & OHW_R4KEOP)
14397                     fputs (" R4KEOP", stdout);
14398                   if (option->info & OHW_R8KPFETCH)
14399                     fputs (" R8KPFETCH", stdout);
14400                   if (option->info & OHW_R5KEOP)
14401                     fputs (" R5KEOP", stdout);
14402                   if (option->info & OHW_R5KCVTL)
14403                     fputs (" R5KCVTL", stdout);
14404                   break;
14405                 case ODK_FILL:
14406                   fputs (" FILL       ", stdout);
14407                   /* XXX Print content of info word?  */
14408                   break;
14409                 case ODK_TAGS:
14410                   fputs (" TAGS       ", stdout);
14411                   /* XXX Print content of info word?  */
14412                   break;
14413                 case ODK_HWAND:
14414                   fputs (" HWAND     ", stdout);
14415                   if (option->info & OHWA0_R4KEOP_CHECKED)
14416                     fputs (" R4KEOP_CHECKED", stdout);
14417                   if (option->info & OHWA0_R4KEOP_CLEAN)
14418                     fputs (" R4KEOP_CLEAN", stdout);
14419                   break;
14420                 case ODK_HWOR:
14421                   fputs (" HWOR      ", stdout);
14422                   if (option->info & OHWA0_R4KEOP_CHECKED)
14423                     fputs (" R4KEOP_CHECKED", stdout);
14424                   if (option->info & OHWA0_R4KEOP_CLEAN)
14425                     fputs (" R4KEOP_CLEAN", stdout);
14426                   break;
14427                 case ODK_GP_GROUP:
14428                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14429                           option->info & OGP_GROUP,
14430                           (option->info & OGP_SELF) >> 16);
14431                   break;
14432                 case ODK_IDENT:
14433                   printf (" IDENT     %#06lx  self-contained %#06lx",
14434                           option->info & OGP_GROUP,
14435                           (option->info & OGP_SELF) >> 16);
14436                   break;
14437                 default:
14438                   /* This shouldn't happen.  */
14439                   printf (" %3d ???     %d %lx",
14440                           option->kind, option->section, option->info);
14441                   break;
14442                 }
14443
14444               len = sizeof (* eopt);
14445               while (len < option->size)
14446                 {
14447                   char datum = * ((char *) eopt + offset + len);
14448
14449                   if (ISPRINT (datum))
14450                     printf ("%c", datum);
14451                   else
14452                     printf ("\\%03o", datum);
14453                   len ++;
14454                 }
14455               fputs ("\n", stdout);
14456
14457               offset += option->size;
14458               ++option;
14459             }
14460
14461           free (eopt);
14462         }
14463     }
14464
14465   if (conflicts_offset != 0 && conflictsno != 0)
14466     {
14467       Elf32_Conflict * iconf;
14468       size_t cnt;
14469
14470       if (dynamic_symbols == NULL)
14471         {
14472           error (_("conflict list found without a dynamic symbol table\n"));
14473           return 0;
14474         }
14475
14476       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14477       if (iconf == NULL)
14478         {
14479           error (_("Out of memory allocating space for dynamic conflicts\n"));
14480           return 0;
14481         }
14482
14483       if (is_32bit_elf)
14484         {
14485           Elf32_External_Conflict * econf32;
14486
14487           econf32 = (Elf32_External_Conflict *)
14488               get_data (NULL, file, conflicts_offset, conflictsno,
14489                         sizeof (* econf32), _("conflict"));
14490           if (!econf32)
14491             return 0;
14492
14493           for (cnt = 0; cnt < conflictsno; ++cnt)
14494             iconf[cnt] = BYTE_GET (econf32[cnt]);
14495
14496           free (econf32);
14497         }
14498       else
14499         {
14500           Elf64_External_Conflict * econf64;
14501
14502           econf64 = (Elf64_External_Conflict *)
14503               get_data (NULL, file, conflicts_offset, conflictsno,
14504                         sizeof (* econf64), _("conflict"));
14505           if (!econf64)
14506             return 0;
14507
14508           for (cnt = 0; cnt < conflictsno; ++cnt)
14509             iconf[cnt] = BYTE_GET (econf64[cnt]);
14510
14511           free (econf64);
14512         }
14513
14514       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14515               (unsigned long) conflictsno);
14516       puts (_("  Num:    Index       Value  Name"));
14517
14518       for (cnt = 0; cnt < conflictsno; ++cnt)
14519         {
14520           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14521
14522           if (iconf[cnt] >= num_dynamic_syms)
14523             printf (_("<corrupt symbol index>"));
14524           else
14525             {
14526               Elf_Internal_Sym * psym;
14527
14528               psym = & dynamic_symbols[iconf[cnt]];
14529               print_vma (psym->st_value, FULL_HEX);
14530               putchar (' ');
14531               if (VALID_DYNAMIC_NAME (psym->st_name))
14532                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14533               else
14534                 printf (_("<corrupt: %14ld>"), psym->st_name);
14535             }
14536           putchar ('\n');
14537         }
14538
14539       free (iconf);
14540     }
14541
14542   if (pltgot != 0 && local_gotno != 0)
14543     {
14544       bfd_vma ent, local_end, global_end;
14545       size_t i, offset;
14546       unsigned char * data;
14547       unsigned char * data_end;
14548       int addr_size;
14549
14550       ent = pltgot;
14551       addr_size = (is_32bit_elf ? 4 : 8);
14552       local_end = pltgot + local_gotno * addr_size;
14553
14554       /* PR binutils/17533 file: 012-111227-0.004  */
14555       if (symtabno < gotsym)
14556         {
14557           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14558                  (unsigned long) gotsym, (unsigned long) symtabno);
14559           return 0;
14560         }
14561
14562       global_end = local_end + (symtabno - gotsym) * addr_size;
14563       /* PR 17531: file: 54c91a34.  */
14564       if (global_end < local_end)
14565         {
14566           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14567           return 0;
14568         }
14569
14570       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14571       data = (unsigned char *) get_data (NULL, file, offset,
14572                                          global_end - pltgot, 1,
14573                                          _("Global Offset Table data"));
14574       if (data == NULL)
14575         return 0;
14576       data_end = data + (global_end - pltgot);
14577
14578       printf (_("\nPrimary GOT:\n"));
14579       printf (_(" Canonical gp value: "));
14580       print_vma (pltgot + 0x7ff0, LONG_HEX);
14581       printf ("\n\n");
14582
14583       printf (_(" Reserved entries:\n"));
14584       printf (_("  %*s %10s %*s Purpose\n"),
14585               addr_size * 2, _("Address"), _("Access"),
14586               addr_size * 2, _("Initial"));
14587       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14588       printf (_(" Lazy resolver\n"));
14589       if (ent == (bfd_vma) -1)
14590         goto got_print_fail;
14591       if (data
14592           && (byte_get (data + ent - pltgot, addr_size)
14593               >> (addr_size * 8 - 1)) != 0)
14594         {
14595           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14596           printf (_(" Module pointer (GNU extension)\n"));
14597           if (ent == (bfd_vma) -1)
14598             goto got_print_fail;
14599         }
14600       printf ("\n");
14601
14602       if (ent < local_end)
14603         {
14604           printf (_(" Local entries:\n"));
14605           printf ("  %*s %10s %*s\n",
14606                   addr_size * 2, _("Address"), _("Access"),
14607                   addr_size * 2, _("Initial"));
14608           while (ent < local_end)
14609             {
14610               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14611               printf ("\n");
14612               if (ent == (bfd_vma) -1)
14613                 goto got_print_fail;
14614             }
14615           printf ("\n");
14616         }
14617
14618       if (gotsym < symtabno)
14619         {
14620           int sym_width;
14621
14622           printf (_(" Global entries:\n"));
14623           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14624                   addr_size * 2, _("Address"),
14625                   _("Access"),
14626                   addr_size * 2, _("Initial"),
14627                   addr_size * 2, _("Sym.Val."),
14628                   _("Type"),
14629                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14630                   _("Ndx"), _("Name"));
14631
14632           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14633
14634           for (i = gotsym; i < symtabno; i++)
14635             {
14636               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14637               printf (" ");
14638
14639               if (dynamic_symbols == NULL)
14640                 printf (_("<no dynamic symbols>"));
14641               else if (i < num_dynamic_syms)
14642                 {
14643                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14644
14645                   print_vma (psym->st_value, LONG_HEX);
14646                   printf (" %-7s %3s ",
14647                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14648                           get_symbol_index_type (psym->st_shndx));
14649
14650                   if (VALID_DYNAMIC_NAME (psym->st_name))
14651                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14652                   else
14653                     printf (_("<corrupt: %14ld>"), psym->st_name);
14654                 }
14655               else
14656                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14657                         (unsigned long) i);
14658
14659               printf ("\n");
14660               if (ent == (bfd_vma) -1)
14661                 break;
14662             }
14663           printf ("\n");
14664         }
14665
14666     got_print_fail:
14667       if (data)
14668         free (data);
14669     }
14670
14671   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14672     {
14673       bfd_vma ent, end;
14674       size_t offset, rel_offset;
14675       unsigned long count, i;
14676       unsigned char * data;
14677       int addr_size, sym_width;
14678       Elf_Internal_Rela * rels;
14679
14680       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14681       if (pltrel == DT_RELA)
14682         {
14683           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14684             return 0;
14685         }
14686       else
14687         {
14688           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14689             return 0;
14690         }
14691
14692       ent = mips_pltgot;
14693       addr_size = (is_32bit_elf ? 4 : 8);
14694       end = mips_pltgot + (2 + count) * addr_size;
14695
14696       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14697       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14698                                          1, _("Procedure Linkage Table data"));
14699       if (data == NULL)
14700         return 0;
14701
14702       printf ("\nPLT GOT:\n\n");
14703       printf (_(" Reserved entries:\n"));
14704       printf (_("  %*s %*s Purpose\n"),
14705               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14706       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14707       printf (_(" PLT lazy resolver\n"));
14708       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14709       printf (_(" Module pointer\n"));
14710       printf ("\n");
14711
14712       printf (_(" Entries:\n"));
14713       printf ("  %*s %*s %*s %-7s %3s %s\n",
14714               addr_size * 2, _("Address"),
14715               addr_size * 2, _("Initial"),
14716               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14717       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14718       for (i = 0; i < count; i++)
14719         {
14720           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14721
14722           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14723           printf (" ");
14724
14725           if (idx >= num_dynamic_syms)
14726             printf (_("<corrupt symbol index: %lu>"), idx);
14727           else
14728             {
14729               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14730
14731               print_vma (psym->st_value, LONG_HEX);
14732               printf (" %-7s %3s ",
14733                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14734                       get_symbol_index_type (psym->st_shndx));
14735               if (VALID_DYNAMIC_NAME (psym->st_name))
14736                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14737               else
14738                 printf (_("<corrupt: %14ld>"), psym->st_name);
14739             }
14740           printf ("\n");
14741         }
14742       printf ("\n");
14743
14744       if (data)
14745         free (data);
14746       free (rels);
14747     }
14748
14749   return 1;
14750 }
14751
14752 static int
14753 process_nds32_specific (FILE * file)
14754 {
14755   Elf_Internal_Shdr *sect = NULL;
14756
14757   sect = find_section (".nds32_e_flags");
14758   if (sect != NULL)
14759     {
14760       unsigned int *flag;
14761
14762       printf ("\nNDS32 elf flags section:\n");
14763       flag = get_data (NULL, file, sect->sh_offset, 1,
14764                        sect->sh_size, _("NDS32 elf flags section"));
14765
14766       switch ((*flag) & 0x3)
14767         {
14768         case 0:
14769           printf ("(VEC_SIZE):\tNo entry.\n");
14770           break;
14771         case 1:
14772           printf ("(VEC_SIZE):\t4 bytes\n");
14773           break;
14774         case 2:
14775           printf ("(VEC_SIZE):\t16 bytes\n");
14776           break;
14777         case 3:
14778           printf ("(VEC_SIZE):\treserved\n");
14779           break;
14780         }
14781     }
14782
14783   return TRUE;
14784 }
14785
14786 static int
14787 process_gnu_liblist (FILE * file)
14788 {
14789   Elf_Internal_Shdr * section;
14790   Elf_Internal_Shdr * string_sec;
14791   Elf32_External_Lib * elib;
14792   char * strtab;
14793   size_t strtab_size;
14794   size_t cnt;
14795   unsigned i;
14796
14797   if (! do_arch)
14798     return 0;
14799
14800   for (i = 0, section = section_headers;
14801        i < elf_header.e_shnum;
14802        i++, section++)
14803     {
14804       switch (section->sh_type)
14805         {
14806         case SHT_GNU_LIBLIST:
14807           if (section->sh_link >= elf_header.e_shnum)
14808             break;
14809
14810           elib = (Elf32_External_Lib *)
14811               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14812                         _("liblist section data"));
14813
14814           if (elib == NULL)
14815             break;
14816           string_sec = section_headers + section->sh_link;
14817
14818           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14819                                       string_sec->sh_size,
14820                                       _("liblist string table"));
14821           if (strtab == NULL
14822               || section->sh_entsize != sizeof (Elf32_External_Lib))
14823             {
14824               free (elib);
14825               free (strtab);
14826               break;
14827             }
14828           strtab_size = string_sec->sh_size;
14829
14830           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14831                   printable_section_name (section),
14832                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14833
14834           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14835
14836           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14837                ++cnt)
14838             {
14839               Elf32_Lib liblist;
14840               time_t atime;
14841               char timebuf[20];
14842               struct tm * tmp;
14843
14844               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14845               atime = BYTE_GET (elib[cnt].l_time_stamp);
14846               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14847               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14848               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14849
14850               tmp = gmtime (&atime);
14851               snprintf (timebuf, sizeof (timebuf),
14852                         "%04u-%02u-%02uT%02u:%02u:%02u",
14853                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14854                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14855
14856               printf ("%3lu: ", (unsigned long) cnt);
14857               if (do_wide)
14858                 printf ("%-20s", liblist.l_name < strtab_size
14859                         ? strtab + liblist.l_name : _("<corrupt>"));
14860               else
14861                 printf ("%-20.20s", liblist.l_name < strtab_size
14862                         ? strtab + liblist.l_name : _("<corrupt>"));
14863               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14864                       liblist.l_version, liblist.l_flags);
14865             }
14866
14867           free (elib);
14868           free (strtab);
14869         }
14870     }
14871
14872   return 1;
14873 }
14874
14875 static const char *
14876 get_note_type (unsigned e_type)
14877 {
14878   static char buff[64];
14879
14880   if (elf_header.e_type == ET_CORE)
14881     switch (e_type)
14882       {
14883       case NT_AUXV:
14884         return _("NT_AUXV (auxiliary vector)");
14885       case NT_PRSTATUS:
14886         return _("NT_PRSTATUS (prstatus structure)");
14887       case NT_FPREGSET:
14888         return _("NT_FPREGSET (floating point registers)");
14889       case NT_PRPSINFO:
14890         return _("NT_PRPSINFO (prpsinfo structure)");
14891       case NT_TASKSTRUCT:
14892         return _("NT_TASKSTRUCT (task structure)");
14893       case NT_PRXFPREG:
14894         return _("NT_PRXFPREG (user_xfpregs structure)");
14895       case NT_PPC_VMX:
14896         return _("NT_PPC_VMX (ppc Altivec registers)");
14897       case NT_PPC_VSX:
14898         return _("NT_PPC_VSX (ppc VSX registers)");
14899       case NT_386_TLS:
14900         return _("NT_386_TLS (x86 TLS information)");
14901       case NT_386_IOPERM:
14902         return _("NT_386_IOPERM (x86 I/O permissions)");
14903       case NT_X86_XSTATE:
14904         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14905       case NT_S390_HIGH_GPRS:
14906         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14907       case NT_S390_TIMER:
14908         return _("NT_S390_TIMER (s390 timer register)");
14909       case NT_S390_TODCMP:
14910         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14911       case NT_S390_TODPREG:
14912         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14913       case NT_S390_CTRS:
14914         return _("NT_S390_CTRS (s390 control registers)");
14915       case NT_S390_PREFIX:
14916         return _("NT_S390_PREFIX (s390 prefix register)");
14917       case NT_S390_LAST_BREAK:
14918         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14919       case NT_S390_SYSTEM_CALL:
14920         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14921       case NT_S390_TDB:
14922         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14923       case NT_S390_VXRS_LOW:
14924         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14925       case NT_S390_VXRS_HIGH:
14926         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14927       case NT_ARM_VFP:
14928         return _("NT_ARM_VFP (arm VFP registers)");
14929       case NT_ARM_TLS:
14930         return _("NT_ARM_TLS (AArch TLS registers)");
14931       case NT_ARM_HW_BREAK:
14932         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14933       case NT_ARM_HW_WATCH:
14934         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14935       case NT_PSTATUS:
14936         return _("NT_PSTATUS (pstatus structure)");
14937       case NT_FPREGS:
14938         return _("NT_FPREGS (floating point registers)");
14939       case NT_PSINFO:
14940         return _("NT_PSINFO (psinfo structure)");
14941       case NT_LWPSTATUS:
14942         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14943       case NT_LWPSINFO:
14944         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14945       case NT_WIN32PSTATUS:
14946         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14947       case NT_SIGINFO:
14948         return _("NT_SIGINFO (siginfo_t data)");
14949       case NT_FILE:
14950         return _("NT_FILE (mapped files)");
14951       default:
14952         break;
14953       }
14954   else
14955     switch (e_type)
14956       {
14957       case NT_VERSION:
14958         return _("NT_VERSION (version)");
14959       case NT_ARCH:
14960         return _("NT_ARCH (architecture)");
14961       default:
14962         break;
14963       }
14964
14965   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14966   return buff;
14967 }
14968
14969 static int
14970 print_core_note (Elf_Internal_Note *pnote)
14971 {
14972   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14973   bfd_vma count, page_size;
14974   unsigned char *descdata, *filenames, *descend;
14975
14976   if (pnote->type != NT_FILE)
14977     return 1;
14978
14979 #ifndef BFD64
14980   if (!is_32bit_elf)
14981     {
14982       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14983       /* Still "successful".  */
14984       return 1;
14985     }
14986 #endif
14987
14988   if (pnote->descsz < 2 * addr_size)
14989     {
14990       printf (_("    Malformed note - too short for header\n"));
14991       return 0;
14992     }
14993
14994   descdata = (unsigned char *) pnote->descdata;
14995   descend = descdata + pnote->descsz;
14996
14997   if (descdata[pnote->descsz - 1] != '\0')
14998     {
14999       printf (_("    Malformed note - does not end with \\0\n"));
15000       return 0;
15001     }
15002
15003   count = byte_get (descdata, addr_size);
15004   descdata += addr_size;
15005
15006   page_size = byte_get (descdata, addr_size);
15007   descdata += addr_size;
15008
15009   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15010     {
15011       printf (_("    Malformed note - too short for supplied file count\n"));
15012       return 0;
15013     }
15014
15015   printf (_("    Page size: "));
15016   print_vma (page_size, DEC);
15017   printf ("\n");
15018
15019   printf (_("    %*s%*s%*s\n"),
15020           (int) (2 + 2 * addr_size), _("Start"),
15021           (int) (4 + 2 * addr_size), _("End"),
15022           (int) (4 + 2 * addr_size), _("Page Offset"));
15023   filenames = descdata + count * 3 * addr_size;
15024   while (--count > 0)
15025     {
15026       bfd_vma start, end, file_ofs;
15027
15028       if (filenames == descend)
15029         {
15030           printf (_("    Malformed note - filenames end too early\n"));
15031           return 0;
15032         }
15033
15034       start = byte_get (descdata, addr_size);
15035       descdata += addr_size;
15036       end = byte_get (descdata, addr_size);
15037       descdata += addr_size;
15038       file_ofs = byte_get (descdata, addr_size);
15039       descdata += addr_size;
15040
15041       printf ("    ");
15042       print_vma (start, FULL_HEX);
15043       printf ("  ");
15044       print_vma (end, FULL_HEX);
15045       printf ("  ");
15046       print_vma (file_ofs, FULL_HEX);
15047       printf ("\n        %s\n", filenames);
15048
15049       filenames += 1 + strlen ((char *) filenames);
15050     }
15051
15052   return 1;
15053 }
15054
15055 static const char *
15056 get_gnu_elf_note_type (unsigned e_type)
15057 {
15058   static char buff[64];
15059
15060   switch (e_type)
15061     {
15062     case NT_GNU_ABI_TAG:
15063       return _("NT_GNU_ABI_TAG (ABI version tag)");
15064     case NT_GNU_HWCAP:
15065       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15066     case NT_GNU_BUILD_ID:
15067       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15068     case NT_GNU_GOLD_VERSION:
15069       return _("NT_GNU_GOLD_VERSION (gold version)");
15070     default:
15071       break;
15072     }
15073
15074   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15075   return buff;
15076 }
15077
15078 static int
15079 print_gnu_note (Elf_Internal_Note *pnote)
15080 {
15081   switch (pnote->type)
15082     {
15083     case NT_GNU_BUILD_ID:
15084       {
15085         unsigned long i;
15086
15087         printf (_("    Build ID: "));
15088         for (i = 0; i < pnote->descsz; ++i)
15089           printf ("%02x", pnote->descdata[i] & 0xff);
15090         printf ("\n");
15091       }
15092       break;
15093
15094     case NT_GNU_ABI_TAG:
15095       {
15096         unsigned long os, major, minor, subminor;
15097         const char *osname;
15098
15099         /* PR 17531: file: 030-599401-0.004.  */
15100         if (pnote->descsz < 16)
15101           {
15102             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15103             break;
15104           }
15105
15106         os = byte_get ((unsigned char *) pnote->descdata, 4);
15107         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15108         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15109         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15110
15111         switch (os)
15112           {
15113           case GNU_ABI_TAG_LINUX:
15114             osname = "Linux";
15115             break;
15116           case GNU_ABI_TAG_HURD:
15117             osname = "Hurd";
15118             break;
15119           case GNU_ABI_TAG_SOLARIS:
15120             osname = "Solaris";
15121             break;
15122           case GNU_ABI_TAG_FREEBSD:
15123             osname = "FreeBSD";
15124             break;
15125           case GNU_ABI_TAG_NETBSD:
15126             osname = "NetBSD";
15127             break;
15128           default:
15129             osname = "Unknown";
15130             break;
15131           }
15132
15133         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15134                 major, minor, subminor);
15135       }
15136       break;
15137
15138     case NT_GNU_GOLD_VERSION:
15139       {
15140         unsigned long i;
15141
15142         printf (_("    Version: "));
15143         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15144           printf ("%c", pnote->descdata[i]);
15145         printf ("\n");
15146       }
15147       break;
15148     }
15149
15150   return 1;
15151 }
15152
15153 static const char *
15154 get_v850_elf_note_type (enum v850_notes n_type)
15155 {
15156   static char buff[64];
15157
15158   switch (n_type)
15159     {
15160     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15161     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15162     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15163     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15164     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15165     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15166     default:
15167       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15168       return buff;
15169     }
15170 }
15171
15172 static int
15173 print_v850_note (Elf_Internal_Note * pnote)
15174 {
15175   unsigned int val;
15176
15177   if (pnote->descsz != 4)
15178     return 0;
15179   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15180
15181   if (val == 0)
15182     {
15183       printf (_("not set\n"));
15184       return 1;
15185     }
15186
15187   switch (pnote->type)
15188     {
15189     case V850_NOTE_ALIGNMENT:
15190       switch (val)
15191         {
15192         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15193         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15194         }
15195       break;
15196
15197     case V850_NOTE_DATA_SIZE:
15198       switch (val)
15199         {
15200         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15201         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15202         }
15203       break;
15204
15205     case V850_NOTE_FPU_INFO:
15206       switch (val)
15207         {
15208         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15209         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15210         }
15211       break;
15212
15213     case V850_NOTE_MMU_INFO:
15214     case V850_NOTE_CACHE_INFO:
15215     case V850_NOTE_SIMD_INFO:
15216       if (val == EF_RH850_SIMD)
15217         {
15218           printf (_("yes\n"));
15219           return 1;
15220         }
15221       break;
15222
15223     default:
15224       /* An 'unknown note type' message will already have been displayed.  */
15225       break;
15226     }
15227
15228   printf (_("unknown value: %x\n"), val);
15229   return 0;
15230 }
15231
15232 static const char *
15233 get_netbsd_elfcore_note_type (unsigned e_type)
15234 {
15235   static char buff[64];
15236
15237   if (e_type == NT_NETBSDCORE_PROCINFO)
15238     {
15239       /* NetBSD core "procinfo" structure.  */
15240       return _("NetBSD procinfo structure");
15241     }
15242
15243   /* As of Jan 2002 there are no other machine-independent notes
15244      defined for NetBSD core files.  If the note type is less
15245      than the start of the machine-dependent note types, we don't
15246      understand it.  */
15247
15248   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15249     {
15250       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15251       return buff;
15252     }
15253
15254   switch (elf_header.e_machine)
15255     {
15256     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15257        and PT_GETFPREGS == mach+2.  */
15258
15259     case EM_OLD_ALPHA:
15260     case EM_ALPHA:
15261     case EM_SPARC:
15262     case EM_SPARC32PLUS:
15263     case EM_SPARCV9:
15264       switch (e_type)
15265         {
15266         case NT_NETBSDCORE_FIRSTMACH + 0:
15267           return _("PT_GETREGS (reg structure)");
15268         case NT_NETBSDCORE_FIRSTMACH + 2:
15269           return _("PT_GETFPREGS (fpreg structure)");
15270         default:
15271           break;
15272         }
15273       break;
15274
15275     /* On all other arch's, PT_GETREGS == mach+1 and
15276        PT_GETFPREGS == mach+3.  */
15277     default:
15278       switch (e_type)
15279         {
15280         case NT_NETBSDCORE_FIRSTMACH + 1:
15281           return _("PT_GETREGS (reg structure)");
15282         case NT_NETBSDCORE_FIRSTMACH + 3:
15283           return _("PT_GETFPREGS (fpreg structure)");
15284         default:
15285           break;
15286         }
15287     }
15288
15289   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15290             e_type - NT_NETBSDCORE_FIRSTMACH);
15291   return buff;
15292 }
15293
15294 static const char *
15295 get_stapsdt_note_type (unsigned e_type)
15296 {
15297   static char buff[64];
15298
15299   switch (e_type)
15300     {
15301     case NT_STAPSDT:
15302       return _("NT_STAPSDT (SystemTap probe descriptors)");
15303
15304     default:
15305       break;
15306     }
15307
15308   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15309   return buff;
15310 }
15311
15312 static int
15313 print_stapsdt_note (Elf_Internal_Note *pnote)
15314 {
15315   int addr_size = is_32bit_elf ? 4 : 8;
15316   char *data = pnote->descdata;
15317   char *data_end = pnote->descdata + pnote->descsz;
15318   bfd_vma pc, base_addr, semaphore;
15319   char *provider, *probe, *arg_fmt;
15320
15321   pc = byte_get ((unsigned char *) data, addr_size);
15322   data += addr_size;
15323   base_addr = byte_get ((unsigned char *) data, addr_size);
15324   data += addr_size;
15325   semaphore = byte_get ((unsigned char *) data, addr_size);
15326   data += addr_size;
15327
15328   provider = data;
15329   data += strlen (data) + 1;
15330   probe = data;
15331   data += strlen (data) + 1;
15332   arg_fmt = data;
15333   data += strlen (data) + 1;
15334
15335   printf (_("    Provider: %s\n"), provider);
15336   printf (_("    Name: %s\n"), probe);
15337   printf (_("    Location: "));
15338   print_vma (pc, FULL_HEX);
15339   printf (_(", Base: "));
15340   print_vma (base_addr, FULL_HEX);
15341   printf (_(", Semaphore: "));
15342   print_vma (semaphore, FULL_HEX);
15343   printf ("\n");
15344   printf (_("    Arguments: %s\n"), arg_fmt);
15345
15346   return data == data_end;
15347 }
15348
15349 static const char *
15350 get_ia64_vms_note_type (unsigned e_type)
15351 {
15352   static char buff[64];
15353
15354   switch (e_type)
15355     {
15356     case NT_VMS_MHD:
15357       return _("NT_VMS_MHD (module header)");
15358     case NT_VMS_LNM:
15359       return _("NT_VMS_LNM (language name)");
15360     case NT_VMS_SRC:
15361       return _("NT_VMS_SRC (source files)");
15362     case NT_VMS_TITLE:
15363       return "NT_VMS_TITLE";
15364     case NT_VMS_EIDC:
15365       return _("NT_VMS_EIDC (consistency check)");
15366     case NT_VMS_FPMODE:
15367       return _("NT_VMS_FPMODE (FP mode)");
15368     case NT_VMS_LINKTIME:
15369       return "NT_VMS_LINKTIME";
15370     case NT_VMS_IMGNAM:
15371       return _("NT_VMS_IMGNAM (image name)");
15372     case NT_VMS_IMGID:
15373       return _("NT_VMS_IMGID (image id)");
15374     case NT_VMS_LINKID:
15375       return _("NT_VMS_LINKID (link id)");
15376     case NT_VMS_IMGBID:
15377       return _("NT_VMS_IMGBID (build id)");
15378     case NT_VMS_GSTNAM:
15379       return _("NT_VMS_GSTNAM (sym table name)");
15380     case NT_VMS_ORIG_DYN:
15381       return "NT_VMS_ORIG_DYN";
15382     case NT_VMS_PATCHTIME:
15383       return "NT_VMS_PATCHTIME";
15384     default:
15385       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15386       return buff;
15387     }
15388 }
15389
15390 static int
15391 print_ia64_vms_note (Elf_Internal_Note * pnote)
15392 {
15393   switch (pnote->type)
15394     {
15395     case NT_VMS_MHD:
15396       if (pnote->descsz > 36)
15397         {
15398           size_t l = strlen (pnote->descdata + 34);
15399           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15400           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15401           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15402           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15403         }
15404       else
15405         printf (_("    Invalid size\n"));
15406       break;
15407     case NT_VMS_LNM:
15408       printf (_("   Language: %s\n"), pnote->descdata);
15409       break;
15410 #ifdef BFD64
15411     case NT_VMS_FPMODE:
15412       printf (_("   Floating Point mode: "));
15413       printf ("0x%016" BFD_VMA_FMT "x\n",
15414               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15415       break;
15416     case NT_VMS_LINKTIME:
15417       printf (_("   Link time: "));
15418       print_vms_time
15419         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15420       printf ("\n");
15421       break;
15422     case NT_VMS_PATCHTIME:
15423       printf (_("   Patch time: "));
15424       print_vms_time
15425         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15426       printf ("\n");
15427       break;
15428     case NT_VMS_ORIG_DYN:
15429       printf (_("   Major id: %u,  minor id: %u\n"),
15430               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15431               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15432       printf (_("   Last modified  : "));
15433       print_vms_time
15434         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15435       printf (_("\n   Link flags  : "));
15436       printf ("0x%016" BFD_VMA_FMT "x\n",
15437               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15438       printf (_("   Header flags: 0x%08x\n"),
15439               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15440       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15441       break;
15442 #endif
15443     case NT_VMS_IMGNAM:
15444       printf (_("    Image name: %s\n"), pnote->descdata);
15445       break;
15446     case NT_VMS_GSTNAM:
15447       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15448       break;
15449     case NT_VMS_IMGID:
15450       printf (_("    Image id: %s\n"), pnote->descdata);
15451       break;
15452     case NT_VMS_LINKID:
15453       printf (_("    Linker id: %s\n"), pnote->descdata);
15454       break;
15455     default:
15456       break;
15457     }
15458   return 1;
15459 }
15460
15461 /* Note that by the ELF standard, the name field is already null byte
15462    terminated, and namesz includes the terminating null byte.
15463    I.E. the value of namesz for the name "FSF" is 4.
15464
15465    If the value of namesz is zero, there is no name present.  */
15466 static int
15467 process_note (Elf_Internal_Note * pnote)
15468 {
15469   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15470   const char * nt;
15471
15472   if (pnote->namesz == 0)
15473     /* If there is no note name, then use the default set of
15474        note type strings.  */
15475     nt = get_note_type (pnote->type);
15476
15477   else if (const_strneq (pnote->namedata, "GNU"))
15478     /* GNU-specific object file notes.  */
15479     nt = get_gnu_elf_note_type (pnote->type);
15480
15481   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15482     /* NetBSD-specific core file notes.  */
15483     nt = get_netbsd_elfcore_note_type (pnote->type);
15484
15485   else if (strneq (pnote->namedata, "SPU/", 4))
15486     {
15487       /* SPU-specific core file notes.  */
15488       nt = pnote->namedata + 4;
15489       name = "SPU";
15490     }
15491
15492   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15493     /* VMS/ia64-specific file notes.  */
15494     nt = get_ia64_vms_note_type (pnote->type);
15495
15496   else if (const_strneq (pnote->namedata, "stapsdt"))
15497     nt = get_stapsdt_note_type (pnote->type);
15498
15499   else
15500     /* Don't recognize this note name; just use the default set of
15501        note type strings.  */
15502     nt = get_note_type (pnote->type);
15503
15504   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15505
15506   if (const_strneq (pnote->namedata, "IPF/VMS"))
15507     return print_ia64_vms_note (pnote);
15508   else if (const_strneq (pnote->namedata, "GNU"))
15509     return print_gnu_note (pnote);
15510   else if (const_strneq (pnote->namedata, "stapsdt"))
15511     return print_stapsdt_note (pnote);
15512   else if (const_strneq (pnote->namedata, "CORE"))
15513     return print_core_note (pnote);
15514   else
15515     return 1;
15516 }
15517
15518
15519 static int
15520 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15521 {
15522   Elf_External_Note * pnotes;
15523   Elf_External_Note * external;
15524   char * end;
15525   int res = 1;
15526
15527   if (length <= 0)
15528     return 0;
15529
15530   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15531                                            _("notes"));
15532   if (pnotes == NULL)
15533     return 0;
15534
15535   external = pnotes;
15536
15537   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15538           (unsigned long) offset, (unsigned long) length);
15539   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15540
15541   end = (char *) pnotes + length;
15542   while ((char *) external < end)
15543     {
15544       Elf_Internal_Note inote;
15545       size_t min_notesz;
15546       char *next;
15547       char * temp = NULL;
15548       size_t data_remaining = end - (char *) external;
15549
15550       if (!is_ia64_vms ())
15551         {
15552           /* PR binutils/15191
15553              Make sure that there is enough data to read.  */
15554           min_notesz = offsetof (Elf_External_Note, name);
15555           if (data_remaining < min_notesz)
15556             {
15557               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15558                     (int) data_remaining);
15559               break;
15560             }
15561           inote.type     = BYTE_GET (external->type);
15562           inote.namesz   = BYTE_GET (external->namesz);
15563           inote.namedata = external->name;
15564           inote.descsz   = BYTE_GET (external->descsz);
15565           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15566           /* PR 17531: file: 3443835e.  */
15567           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15568             {
15569               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15570               inote.descdata = inote.namedata;
15571               inote.namesz   = 0;
15572             }
15573
15574           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15575           next = inote.descdata + align_power (inote.descsz, 2);
15576         }
15577       else
15578         {
15579           Elf64_External_VMS_Note *vms_external;
15580
15581           /* PR binutils/15191
15582              Make sure that there is enough data to read.  */
15583           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15584           if (data_remaining < min_notesz)
15585             {
15586               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15587                     (int) data_remaining);
15588               break;
15589             }
15590
15591           vms_external = (Elf64_External_VMS_Note *) external;
15592           inote.type     = BYTE_GET (vms_external->type);
15593           inote.namesz   = BYTE_GET (vms_external->namesz);
15594           inote.namedata = vms_external->name;
15595           inote.descsz   = BYTE_GET (vms_external->descsz);
15596           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15597           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15598           next = inote.descdata + align_power (inote.descsz, 3);
15599         }
15600
15601       if (inote.descdata < (char *) external + min_notesz
15602           || next < (char *) external + min_notesz
15603           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15604           || inote.namedata + inote.namesz < inote.namedata
15605           || inote.descdata + inote.descsz < inote.descdata
15606           || data_remaining < (size_t)(next - (char *) external))
15607         {
15608           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15609                 (unsigned long) ((char *) external - (char *) pnotes));
15610           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15611                 inote.type, inote.namesz, inote.descsz);
15612           break;
15613         }
15614
15615       external = (Elf_External_Note *) next;
15616
15617       /* Verify that name is null terminated.  It appears that at least
15618          one version of Linux (RedHat 6.0) generates corefiles that don't
15619          comply with the ELF spec by failing to include the null byte in
15620          namesz.  */
15621       if (inote.namedata[inote.namesz - 1] != '\0')
15622         {
15623           temp = (char *) malloc (inote.namesz + 1);
15624           if (temp == NULL)
15625             {
15626               error (_("Out of memory allocating space for inote name\n"));
15627               res = 0;
15628               break;
15629             }
15630
15631           strncpy (temp, inote.namedata, inote.namesz);
15632           temp[inote.namesz] = 0;
15633
15634           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15635           inote.namedata = temp;
15636         }
15637
15638       res &= process_note (& inote);
15639
15640       if (temp != NULL)
15641         {
15642           free (temp);
15643           temp = NULL;
15644         }
15645     }
15646
15647   free (pnotes);
15648
15649   return res;
15650 }
15651
15652 static int
15653 process_corefile_note_segments (FILE * file)
15654 {
15655   Elf_Internal_Phdr * segment;
15656   unsigned int i;
15657   int res = 1;
15658
15659   if (! get_program_headers (file))
15660       return 0;
15661
15662   for (i = 0, segment = program_headers;
15663        i < elf_header.e_phnum;
15664        i++, segment++)
15665     {
15666       if (segment->p_type == PT_NOTE)
15667         res &= process_corefile_note_segment (file,
15668                                               (bfd_vma) segment->p_offset,
15669                                               (bfd_vma) segment->p_filesz);
15670     }
15671
15672   return res;
15673 }
15674
15675 static int
15676 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15677 {
15678   Elf_External_Note * pnotes;
15679   Elf_External_Note * external;
15680   char * end;
15681   int res = 1;
15682
15683   if (length <= 0)
15684     return 0;
15685
15686   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15687                                            _("v850 notes"));
15688   if (pnotes == NULL)
15689     return 0;
15690
15691   external = pnotes;
15692   end = (char*) pnotes + length;
15693
15694   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15695           (unsigned long) offset, (unsigned long) length);
15696
15697   while ((char *) external + sizeof (Elf_External_Note) < end)
15698     {
15699       Elf_External_Note * next;
15700       Elf_Internal_Note inote;
15701
15702       inote.type     = BYTE_GET (external->type);
15703       inote.namesz   = BYTE_GET (external->namesz);
15704       inote.namedata = external->name;
15705       inote.descsz   = BYTE_GET (external->descsz);
15706       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15707       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15708
15709       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15710         {
15711           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15712           inote.descdata = inote.namedata;
15713           inote.namesz   = 0;
15714         }
15715
15716       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15717
15718       if (   ((char *) next > end)
15719           || ((char *) next <  (char *) pnotes))
15720         {
15721           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15722                 (unsigned long) ((char *) external - (char *) pnotes));
15723           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15724                 inote.type, inote.namesz, inote.descsz);
15725           break;
15726         }
15727
15728       external = next;
15729
15730       /* Prevent out-of-bounds indexing.  */
15731       if (   inote.namedata + inote.namesz > end
15732           || inote.namedata + inote.namesz < inote.namedata)
15733         {
15734           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15735                 (unsigned long) ((char *) external - (char *) pnotes));
15736           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15737                 inote.type, inote.namesz, inote.descsz);
15738           break;
15739         }
15740
15741       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15742
15743       if (! print_v850_note (& inote))
15744         {
15745           res = 0;
15746           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15747                   inote.namesz, inote.descsz);
15748         }
15749     }
15750
15751   free (pnotes);
15752
15753   return res;
15754 }
15755
15756 static int
15757 process_note_sections (FILE * file)
15758 {
15759   Elf_Internal_Shdr * section;
15760   unsigned long i;
15761   int n = 0;
15762   int res = 1;
15763
15764   for (i = 0, section = section_headers;
15765        i < elf_header.e_shnum && section != NULL;
15766        i++, section++)
15767     {
15768       if (section->sh_type == SHT_NOTE)
15769         {
15770           res &= process_corefile_note_segment (file,
15771                                                 (bfd_vma) section->sh_offset,
15772                                                 (bfd_vma) section->sh_size);
15773           n++;
15774         }
15775
15776       if ((   elf_header.e_machine == EM_V800
15777            || elf_header.e_machine == EM_V850
15778            || elf_header.e_machine == EM_CYGNUS_V850)
15779           && section->sh_type == SHT_RENESAS_INFO)
15780         {
15781           res &= process_v850_notes (file,
15782                                      (bfd_vma) section->sh_offset,
15783                                      (bfd_vma) section->sh_size);
15784           n++;
15785         }
15786     }
15787
15788   if (n == 0)
15789     /* Try processing NOTE segments instead.  */
15790     return process_corefile_note_segments (file);
15791
15792   return res;
15793 }
15794
15795 static int
15796 process_notes (FILE * file)
15797 {
15798   /* If we have not been asked to display the notes then do nothing.  */
15799   if (! do_notes)
15800     return 1;
15801
15802   if (elf_header.e_type != ET_CORE)
15803     return process_note_sections (file);
15804
15805   /* No program headers means no NOTE segment.  */
15806   if (elf_header.e_phnum > 0)
15807     return process_corefile_note_segments (file);
15808
15809   printf (_("No note segments present in the core file.\n"));
15810   return 1;
15811 }
15812
15813 static int
15814 process_arch_specific (FILE * file)
15815 {
15816   if (! do_arch)
15817     return 1;
15818
15819   switch (elf_header.e_machine)
15820     {
15821     case EM_ARM:
15822       return process_arm_specific (file);
15823     case EM_MIPS:
15824     case EM_MIPS_RS3_LE:
15825       return process_mips_specific (file);
15826       break;
15827     case EM_NDS32:
15828       return process_nds32_specific (file);
15829       break;
15830     case EM_PPC:
15831       return process_power_specific (file);
15832       break;
15833     case EM_S390:
15834     case EM_S390_OLD:
15835       return process_s390_specific (file);
15836       break;
15837     case EM_SPARC:
15838     case EM_SPARC32PLUS:
15839     case EM_SPARCV9:
15840       return process_sparc_specific (file);
15841       break;
15842     case EM_TI_C6000:
15843       return process_tic6x_specific (file);
15844       break;
15845     case EM_MSP430:
15846       return process_msp430x_specific (file);
15847     default:
15848       break;
15849     }
15850   return 1;
15851 }
15852
15853 static int
15854 get_file_header (FILE * file)
15855 {
15856   /* Read in the identity array.  */
15857   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15858     return 0;
15859
15860   /* Determine how to read the rest of the header.  */
15861   switch (elf_header.e_ident[EI_DATA])
15862     {
15863     default: /* fall through */
15864     case ELFDATANONE: /* fall through */
15865     case ELFDATA2LSB:
15866       byte_get = byte_get_little_endian;
15867       byte_put = byte_put_little_endian;
15868       break;
15869     case ELFDATA2MSB:
15870       byte_get = byte_get_big_endian;
15871       byte_put = byte_put_big_endian;
15872       break;
15873     }
15874
15875   /* For now we only support 32 bit and 64 bit ELF files.  */
15876   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15877
15878   /* Read in the rest of the header.  */
15879   if (is_32bit_elf)
15880     {
15881       Elf32_External_Ehdr ehdr32;
15882
15883       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15884         return 0;
15885
15886       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15887       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15888       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15889       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15890       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15891       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15892       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15893       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15894       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15895       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15896       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15897       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15898       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15899     }
15900   else
15901     {
15902       Elf64_External_Ehdr ehdr64;
15903
15904       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15905          we will not be able to cope with the 64bit data found in
15906          64 ELF files.  Detect this now and abort before we start
15907          overwriting things.  */
15908       if (sizeof (bfd_vma) < 8)
15909         {
15910           error (_("This instance of readelf has been built without support for a\n\
15911 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15912           return 0;
15913         }
15914
15915       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15916         return 0;
15917
15918       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15919       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15920       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15921       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15922       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15923       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15924       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15925       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15926       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15927       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15928       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15929       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15930       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15931     }
15932
15933   if (elf_header.e_shoff)
15934     {
15935       /* There may be some extensions in the first section header.  Don't
15936          bomb if we can't read it.  */
15937       if (is_32bit_elf)
15938         get_32bit_section_headers (file, TRUE);
15939       else
15940         get_64bit_section_headers (file, TRUE);
15941     }
15942
15943   return 1;
15944 }
15945
15946 /* Process one ELF object file according to the command line options.
15947    This file may actually be stored in an archive.  The file is
15948    positioned at the start of the ELF object.  */
15949
15950 static int
15951 process_object (char * file_name, FILE * file)
15952 {
15953   unsigned int i;
15954
15955   if (! get_file_header (file))
15956     {
15957       error (_("%s: Failed to read file header\n"), file_name);
15958       return 1;
15959     }
15960
15961   /* Initialise per file variables.  */
15962   for (i = ARRAY_SIZE (version_info); i--;)
15963     version_info[i] = 0;
15964
15965   for (i = ARRAY_SIZE (dynamic_info); i--;)
15966     dynamic_info[i] = 0;
15967   dynamic_info_DT_GNU_HASH = 0;
15968
15969   /* Process the file.  */
15970   if (show_name)
15971     printf (_("\nFile: %s\n"), file_name);
15972
15973   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15974      Note we do this even if cmdline_dump_sects is empty because we
15975      must make sure that the dump_sets array is zeroed out before each
15976      object file is processed.  */
15977   if (num_dump_sects > num_cmdline_dump_sects)
15978     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15979
15980   if (num_cmdline_dump_sects > 0)
15981     {
15982       if (num_dump_sects == 0)
15983         /* A sneaky way of allocating the dump_sects array.  */
15984         request_dump_bynumber (num_cmdline_dump_sects, 0);
15985
15986       assert (num_dump_sects >= num_cmdline_dump_sects);
15987       memcpy (dump_sects, cmdline_dump_sects,
15988               num_cmdline_dump_sects * sizeof (* dump_sects));
15989     }
15990
15991   if (! process_file_header ())
15992     return 1;
15993
15994   if (! process_section_headers (file))
15995     {
15996       /* Without loaded section headers we cannot process lots of
15997          things.  */
15998       do_unwind = do_version = do_dump = do_arch = 0;
15999
16000       if (! do_using_dynamic)
16001         do_syms = do_dyn_syms = do_reloc = 0;
16002     }
16003
16004   if (! process_section_groups (file))
16005     {
16006       /* Without loaded section groups we cannot process unwind.  */
16007       do_unwind = 0;
16008     }
16009
16010   if (process_program_headers (file))
16011     process_dynamic_section (file);
16012
16013   process_relocs (file);
16014
16015   process_unwind (file);
16016
16017   process_symbol_table (file);
16018
16019   process_syminfo (file);
16020
16021   process_version_sections (file);
16022
16023   process_section_contents (file);
16024
16025   process_notes (file);
16026
16027   process_gnu_liblist (file);
16028
16029   process_arch_specific (file);
16030
16031   if (program_headers)
16032     {
16033       free (program_headers);
16034       program_headers = NULL;
16035     }
16036
16037   if (section_headers)
16038     {
16039       free (section_headers);
16040       section_headers = NULL;
16041     }
16042
16043   if (string_table)
16044     {
16045       free (string_table);
16046       string_table = NULL;
16047       string_table_length = 0;
16048     }
16049
16050   if (dynamic_strings)
16051     {
16052       free (dynamic_strings);
16053       dynamic_strings = NULL;
16054       dynamic_strings_length = 0;
16055     }
16056
16057   if (dynamic_symbols)
16058     {
16059       free (dynamic_symbols);
16060       dynamic_symbols = NULL;
16061       num_dynamic_syms = 0;
16062     }
16063
16064   if (dynamic_syminfo)
16065     {
16066       free (dynamic_syminfo);
16067       dynamic_syminfo = NULL;
16068     }
16069
16070   if (dynamic_section)
16071     {
16072       free (dynamic_section);
16073       dynamic_section = NULL;
16074     }
16075
16076   if (section_headers_groups)
16077     {
16078       free (section_headers_groups);
16079       section_headers_groups = NULL;
16080     }
16081
16082   if (section_groups)
16083     {
16084       struct group_list * g;
16085       struct group_list * next;
16086
16087       for (i = 0; i < group_count; i++)
16088         {
16089           for (g = section_groups [i].root; g != NULL; g = next)
16090             {
16091               next = g->next;
16092               free (g);
16093             }
16094         }
16095
16096       free (section_groups);
16097       section_groups = NULL;
16098     }
16099
16100   free_debug_memory ();
16101
16102   return 0;
16103 }
16104
16105 /* Process an ELF archive.
16106    On entry the file is positioned just after the ARMAG string.  */
16107
16108 static int
16109 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16110 {
16111   struct archive_info arch;
16112   struct archive_info nested_arch;
16113   size_t got;
16114   int ret;
16115
16116   show_name = 1;
16117
16118   /* The ARCH structure is used to hold information about this archive.  */
16119   arch.file_name = NULL;
16120   arch.file = NULL;
16121   arch.index_array = NULL;
16122   arch.sym_table = NULL;
16123   arch.longnames = NULL;
16124
16125   /* The NESTED_ARCH structure is used as a single-item cache of information
16126      about a nested archive (when members of a thin archive reside within
16127      another regular archive file).  */
16128   nested_arch.file_name = NULL;
16129   nested_arch.file = NULL;
16130   nested_arch.index_array = NULL;
16131   nested_arch.sym_table = NULL;
16132   nested_arch.longnames = NULL;
16133
16134   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16135     {
16136       ret = 1;
16137       goto out;
16138     }
16139
16140   if (do_archive_index)
16141     {
16142       if (arch.sym_table == NULL)
16143         error (_("%s: unable to dump the index as none was found\n"), file_name);
16144       else
16145         {
16146           unsigned long i, l;
16147           unsigned long current_pos;
16148
16149           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16150                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16151           current_pos = ftell (file);
16152
16153           for (i = l = 0; i < arch.index_num; i++)
16154             {
16155               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16156                 {
16157                   char * member_name;
16158
16159                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16160
16161                   if (member_name != NULL)
16162                     {
16163                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16164
16165                       if (qualified_name != NULL)
16166                         {
16167                           printf (_("Contents of binary %s at offset "), qualified_name);
16168                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16169                           putchar ('\n');
16170                           free (qualified_name);
16171                         }
16172                     }
16173                 }
16174
16175               if (l >= arch.sym_size)
16176                 {
16177                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16178                          file_name);
16179                   break;
16180                 }
16181               /* PR 17531: file: 0b6630b2.  */
16182               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16183               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16184             }
16185
16186           if (arch.uses_64bit_indicies)
16187             l = (l + 7) & ~ 7;
16188           else
16189             l += l & 1;
16190
16191           if (l < arch.sym_size)
16192             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16193                    file_name, arch.sym_size - l);
16194
16195           if (fseek (file, current_pos, SEEK_SET) != 0)
16196             {
16197               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16198               ret = 1;
16199               goto out;
16200             }
16201         }
16202
16203       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16204           && !do_segments && !do_header && !do_dump && !do_version
16205           && !do_histogram && !do_debugging && !do_arch && !do_notes
16206           && !do_section_groups && !do_dyn_syms)
16207         {
16208           ret = 0; /* Archive index only.  */
16209           goto out;
16210         }
16211     }
16212
16213   ret = 0;
16214
16215   while (1)
16216     {
16217       char * name;
16218       size_t namelen;
16219       char * qualified_name;
16220
16221       /* Read the next archive header.  */
16222       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16223         {
16224           error (_("%s: failed to seek to next archive header\n"), file_name);
16225           return 1;
16226         }
16227       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16228       if (got != sizeof arch.arhdr)
16229         {
16230           if (got == 0)
16231             break;
16232           error (_("%s: failed to read archive header\n"), file_name);
16233           ret = 1;
16234           break;
16235         }
16236       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16237         {
16238           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16239           ret = 1;
16240           break;
16241         }
16242
16243       arch.next_arhdr_offset += sizeof arch.arhdr;
16244
16245       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16246       if (archive_file_size & 01)
16247         ++archive_file_size;
16248
16249       name = get_archive_member_name (&arch, &nested_arch);
16250       if (name == NULL)
16251         {
16252           error (_("%s: bad archive file name\n"), file_name);
16253           ret = 1;
16254           break;
16255         }
16256       namelen = strlen (name);
16257
16258       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16259       if (qualified_name == NULL)
16260         {
16261           error (_("%s: bad archive file name\n"), file_name);
16262           ret = 1;
16263           break;
16264         }
16265
16266       if (is_thin_archive && arch.nested_member_origin == 0)
16267         {
16268           /* This is a proxy for an external member of a thin archive.  */
16269           FILE * member_file;
16270           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16271           if (member_file_name == NULL)
16272             {
16273               ret = 1;
16274               break;
16275             }
16276
16277           member_file = fopen (member_file_name, "rb");
16278           if (member_file == NULL)
16279             {
16280               error (_("Input file '%s' is not readable.\n"), member_file_name);
16281               free (member_file_name);
16282               ret = 1;
16283               break;
16284             }
16285
16286           archive_file_offset = arch.nested_member_origin;
16287
16288           ret |= process_object (qualified_name, member_file);
16289
16290           fclose (member_file);
16291           free (member_file_name);
16292         }
16293       else if (is_thin_archive)
16294         {
16295           /* PR 15140: Allow for corrupt thin archives.  */
16296           if (nested_arch.file == NULL)
16297             {
16298               error (_("%s: contains corrupt thin archive: %s\n"),
16299                      file_name, name);
16300               ret = 1;
16301               break;
16302             }
16303
16304           /* This is a proxy for a member of a nested archive.  */
16305           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16306
16307           /* The nested archive file will have been opened and setup by
16308              get_archive_member_name.  */
16309           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16310             {
16311               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16312               ret = 1;
16313               break;
16314             }
16315
16316           ret |= process_object (qualified_name, nested_arch.file);
16317         }
16318       else
16319         {
16320           archive_file_offset = arch.next_arhdr_offset;
16321           arch.next_arhdr_offset += archive_file_size;
16322
16323           ret |= process_object (qualified_name, file);
16324         }
16325
16326       if (dump_sects != NULL)
16327         {
16328           free (dump_sects);
16329           dump_sects = NULL;
16330           num_dump_sects = 0;
16331         }
16332
16333       free (qualified_name);
16334     }
16335
16336  out:
16337   if (nested_arch.file != NULL)
16338     fclose (nested_arch.file);
16339   release_archive (&nested_arch);
16340   release_archive (&arch);
16341
16342   return ret;
16343 }
16344
16345 static int
16346 process_file (char * file_name)
16347 {
16348   FILE * file;
16349   struct stat statbuf;
16350   char armag[SARMAG];
16351   int ret;
16352
16353   if (stat (file_name, &statbuf) < 0)
16354     {
16355       if (errno == ENOENT)
16356         error (_("'%s': No such file\n"), file_name);
16357       else
16358         error (_("Could not locate '%s'.  System error message: %s\n"),
16359                file_name, strerror (errno));
16360       return 1;
16361     }
16362
16363   if (! S_ISREG (statbuf.st_mode))
16364     {
16365       error (_("'%s' is not an ordinary file\n"), file_name);
16366       return 1;
16367     }
16368
16369   file = fopen (file_name, "rb");
16370   if (file == NULL)
16371     {
16372       error (_("Input file '%s' is not readable.\n"), file_name);
16373       return 1;
16374     }
16375
16376   if (fread (armag, SARMAG, 1, file) != 1)
16377     {
16378       error (_("%s: Failed to read file's magic number\n"), file_name);
16379       fclose (file);
16380       return 1;
16381     }
16382
16383   current_file_size = (bfd_size_type) statbuf.st_size;
16384
16385   if (memcmp (armag, ARMAG, SARMAG) == 0)
16386     ret = process_archive (file_name, file, FALSE);
16387   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16388     ret = process_archive (file_name, file, TRUE);
16389   else
16390     {
16391       if (do_archive_index)
16392         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16393                file_name);
16394
16395       rewind (file);
16396       archive_file_size = archive_file_offset = 0;
16397       ret = process_object (file_name, file);
16398     }
16399
16400   fclose (file);
16401
16402   current_file_size = 0;
16403   return ret;
16404 }
16405
16406 #ifdef SUPPORT_DISASSEMBLY
16407 /* Needed by the i386 disassembler.  For extra credit, someone could
16408    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16409    symbols.  */
16410
16411 void
16412 print_address (unsigned int addr, FILE * outfile)
16413 {
16414   fprintf (outfile,"0x%8.8x", addr);
16415 }
16416
16417 /* Needed by the i386 disassembler.  */
16418 void
16419 db_task_printsym (unsigned int addr)
16420 {
16421   print_address (addr, stderr);
16422 }
16423 #endif
16424
16425 int
16426 main (int argc, char ** argv)
16427 {
16428   int err;
16429
16430 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16431   setlocale (LC_MESSAGES, "");
16432 #endif
16433 #if defined (HAVE_SETLOCALE)
16434   setlocale (LC_CTYPE, "");
16435 #endif
16436   bindtextdomain (PACKAGE, LOCALEDIR);
16437   textdomain (PACKAGE);
16438
16439   expandargv (&argc, &argv);
16440
16441   parse_args (argc, argv);
16442
16443   if (num_dump_sects > 0)
16444     {
16445       /* Make a copy of the dump_sects array.  */
16446       cmdline_dump_sects = (dump_type *)
16447           malloc (num_dump_sects * sizeof (* dump_sects));
16448       if (cmdline_dump_sects == NULL)
16449         error (_("Out of memory allocating dump request table.\n"));
16450       else
16451         {
16452           memcpy (cmdline_dump_sects, dump_sects,
16453                   num_dump_sects * sizeof (* dump_sects));
16454           num_cmdline_dump_sects = num_dump_sects;
16455         }
16456     }
16457
16458   if (optind < (argc - 1))
16459     show_name = 1;
16460   else if (optind >= argc)
16461     {
16462       warn (_("Nothing to do.\n"));
16463       usage (stderr);
16464     }
16465
16466   err = 0;
16467   while (optind < argc)
16468     err |= process_file (argv[optind++]);
16469
16470   if (dump_sects != NULL)
16471     free (dump_sects);
16472   if (cmdline_dump_sects != NULL)
16473     free (cmdline_dump_sects);
16474
16475   return err;
16476 }