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   char *               data;
12008   char *               end;
12009   char *               real_start;
12010   char *               start;
12011   bfd_boolean          some_strings_shown;
12012
12013   real_start = start = get_section_contents (section, file);
12014   if (start == NULL)
12015     return;
12016   num_bytes = section->sh_size;
12017
12018   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12019
12020   if (decompress_dumps)
12021     {
12022       dwarf_size_type new_size = num_bytes;
12023       dwarf_size_type uncompressed_size = 0;
12024
12025       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12026         {
12027           Elf_Internal_Chdr chdr;
12028           unsigned int compression_header_size
12029             = get_compression_header (& chdr, (unsigned char *) start);
12030
12031           if (chdr.ch_type == ELFCOMPRESS_ZLIB
12032               && chdr.ch_addralign == section->sh_addralign)
12033             {
12034               uncompressed_size = chdr.ch_size;
12035               start += compression_header_size;
12036               new_size -= compression_header_size;
12037             }
12038         }
12039       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12040         {
12041           /* Read the zlib header.  In this case, it should be "ZLIB"
12042              followed by the uncompressed section size, 8 bytes in
12043              big-endian order.  */
12044           uncompressed_size = start[4]; uncompressed_size <<= 8;
12045           uncompressed_size += start[5]; uncompressed_size <<= 8;
12046           uncompressed_size += start[6]; uncompressed_size <<= 8;
12047           uncompressed_size += start[7]; uncompressed_size <<= 8;
12048           uncompressed_size += start[8]; uncompressed_size <<= 8;
12049           uncompressed_size += start[9]; uncompressed_size <<= 8;
12050           uncompressed_size += start[10]; uncompressed_size <<= 8;
12051           uncompressed_size += start[11];
12052           start += 12;
12053           new_size -= 12;
12054         }
12055
12056       if (uncompressed_size
12057           && uncompress_section_contents ((unsigned char **) & start,
12058                                           uncompressed_size, & new_size))
12059         num_bytes = new_size;
12060     }
12061
12062   /* If the section being dumped has relocations against it the user might
12063      be expecting these relocations to have been applied.  Check for this
12064      case and issue a warning message in order to avoid confusion.
12065      FIXME: Maybe we ought to have an option that dumps a section with
12066      relocs applied ?  */
12067   for (relsec = section_headers;
12068        relsec < section_headers + elf_header.e_shnum;
12069        ++relsec)
12070     {
12071       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12072           || relsec->sh_info >= elf_header.e_shnum
12073           || section_headers + relsec->sh_info != section
12074           || relsec->sh_size == 0
12075           || relsec->sh_link >= elf_header.e_shnum)
12076         continue;
12077
12078       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12079       break;
12080     }
12081
12082   data = start;
12083   end  = start + num_bytes;
12084   some_strings_shown = FALSE;
12085
12086   while (data < end)
12087     {
12088       while (!ISPRINT (* data))
12089         if (++ data >= end)
12090           break;
12091
12092       if (data < end)
12093         {
12094           size_t maxlen = end - data;
12095
12096 #ifndef __MSVCRT__
12097           /* PR 11128: Use two separate invocations in order to work
12098              around bugs in the Solaris 8 implementation of printf.  */
12099           printf ("  [%6tx]  ", data - start);
12100 #else
12101           printf ("  [%6Ix]  ", (size_t) (data - start));
12102 #endif
12103           if (maxlen > 0)
12104             {
12105               print_symbol ((int) maxlen, data);
12106               putchar ('\n');
12107               data += strnlen (data, maxlen);
12108             }
12109           else
12110             {
12111               printf (_("<corrupt>\n"));
12112               data = end;
12113             }
12114           some_strings_shown = TRUE;
12115         }
12116     }
12117
12118   if (! some_strings_shown)
12119     printf (_("  No strings found in this section."));
12120
12121   free (real_start);
12122
12123   putchar ('\n');
12124 }
12125
12126 static void
12127 dump_section_as_bytes (Elf_Internal_Shdr * section,
12128                        FILE * file,
12129                        bfd_boolean relocate)
12130 {
12131   Elf_Internal_Shdr * relsec;
12132   bfd_size_type       bytes;
12133   bfd_size_type       section_size;
12134   bfd_vma             addr;
12135   unsigned char *     data;
12136   unsigned char *     real_start;
12137   unsigned char *     start;
12138
12139   real_start = start = (unsigned char *) get_section_contents (section, file);
12140   if (start == NULL)
12141     return;
12142   section_size = section->sh_size;
12143
12144   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12145
12146   if (decompress_dumps)
12147     {
12148       dwarf_size_type new_size = section_size;
12149       dwarf_size_type uncompressed_size = 0;
12150
12151       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12152         {
12153           Elf_Internal_Chdr chdr;
12154           unsigned int compression_header_size
12155             = get_compression_header (& chdr, start);
12156
12157           if (chdr.ch_type == ELFCOMPRESS_ZLIB
12158               && chdr.ch_addralign == section->sh_addralign)
12159             {
12160               uncompressed_size = chdr.ch_size;
12161               start += compression_header_size;
12162               new_size -= compression_header_size;
12163             }
12164         }
12165       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12166         {
12167           /* Read the zlib header.  In this case, it should be "ZLIB"
12168              followed by the uncompressed section size, 8 bytes in
12169              big-endian order.  */
12170           uncompressed_size = start[4]; uncompressed_size <<= 8;
12171           uncompressed_size += start[5]; uncompressed_size <<= 8;
12172           uncompressed_size += start[6]; uncompressed_size <<= 8;
12173           uncompressed_size += start[7]; uncompressed_size <<= 8;
12174           uncompressed_size += start[8]; uncompressed_size <<= 8;
12175           uncompressed_size += start[9]; uncompressed_size <<= 8;
12176           uncompressed_size += start[10]; uncompressed_size <<= 8;
12177           uncompressed_size += start[11];
12178           start += 12;
12179           new_size -= 12;
12180         }
12181
12182       if (uncompressed_size
12183           && uncompress_section_contents (& start, uncompressed_size,
12184                                           & new_size))
12185         section_size = new_size;
12186     }
12187
12188   if (relocate)
12189     {
12190       apply_relocations (file, section, start, section_size, NULL, NULL);
12191     }
12192   else
12193     {
12194       /* If the section being dumped has relocations against it the user might
12195          be expecting these relocations to have been applied.  Check for this
12196          case and issue a warning message in order to avoid confusion.
12197          FIXME: Maybe we ought to have an option that dumps a section with
12198          relocs applied ?  */
12199       for (relsec = section_headers;
12200            relsec < section_headers + elf_header.e_shnum;
12201            ++relsec)
12202         {
12203           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12204               || relsec->sh_info >= elf_header.e_shnum
12205               || section_headers + relsec->sh_info != section
12206               || relsec->sh_size == 0
12207               || relsec->sh_link >= elf_header.e_shnum)
12208             continue;
12209
12210           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12211           break;
12212         }
12213     }
12214
12215   addr = section->sh_addr;
12216   bytes = section_size;
12217   data = start;
12218
12219   while (bytes)
12220     {
12221       int j;
12222       int k;
12223       int lbytes;
12224
12225       lbytes = (bytes > 16 ? 16 : bytes);
12226
12227       printf ("  0x%8.8lx ", (unsigned long) addr);
12228
12229       for (j = 0; j < 16; j++)
12230         {
12231           if (j < lbytes)
12232             printf ("%2.2x", data[j]);
12233           else
12234             printf ("  ");
12235
12236           if ((j & 3) == 3)
12237             printf (" ");
12238         }
12239
12240       for (j = 0; j < lbytes; j++)
12241         {
12242           k = data[j];
12243           if (k >= ' ' && k < 0x7f)
12244             printf ("%c", k);
12245           else
12246             printf (".");
12247         }
12248
12249       putchar ('\n');
12250
12251       data  += lbytes;
12252       addr  += lbytes;
12253       bytes -= lbytes;
12254     }
12255
12256   free (real_start);
12257
12258   putchar ('\n');
12259 }
12260
12261 static int
12262 load_specific_debug_section (enum dwarf_section_display_enum debug,
12263                              const Elf_Internal_Shdr * sec, void * file)
12264 {
12265   struct dwarf_section * section = &debug_displays [debug].section;
12266   char buf [64];
12267
12268   /* If it is already loaded, do nothing.  */
12269   if (section->start != NULL)
12270     return 1;
12271
12272   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12273   section->address = sec->sh_addr;
12274   section->user_data = NULL;
12275   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12276                                                sec->sh_offset, 1,
12277                                                sec->sh_size, buf);
12278   if (section->start == NULL)
12279     section->size = 0;
12280   else
12281     {
12282       unsigned char *start = section->start;
12283       dwarf_size_type size = sec->sh_size;
12284       dwarf_size_type uncompressed_size = 0;
12285
12286       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12287         {
12288           Elf_Internal_Chdr chdr;
12289           unsigned int compression_header_size
12290             = get_compression_header (&chdr, start);
12291           if (chdr.ch_type != ELFCOMPRESS_ZLIB
12292               || chdr.ch_addralign != sec->sh_addralign)
12293             return 0;
12294           uncompressed_size = chdr.ch_size;
12295           start += compression_header_size;
12296           size -= compression_header_size;
12297         }
12298       else if (size > 12 && streq ((char *) start, "ZLIB"))
12299         {
12300           /* Read the zlib header.  In this case, it should be "ZLIB"
12301              followed by the uncompressed section size, 8 bytes in
12302              big-endian order.  */
12303           uncompressed_size = start[4]; uncompressed_size <<= 8;
12304           uncompressed_size += start[5]; uncompressed_size <<= 8;
12305           uncompressed_size += start[6]; uncompressed_size <<= 8;
12306           uncompressed_size += start[7]; uncompressed_size <<= 8;
12307           uncompressed_size += start[8]; uncompressed_size <<= 8;
12308           uncompressed_size += start[9]; uncompressed_size <<= 8;
12309           uncompressed_size += start[10]; uncompressed_size <<= 8;
12310           uncompressed_size += start[11];
12311           start += 12;
12312           size -= 12;
12313         }
12314
12315       if (uncompressed_size
12316           && uncompress_section_contents (&start, uncompressed_size,
12317                                           &size))
12318         {
12319           /* Free the compressed buffer, update the section buffer
12320              and the section size if uncompress is successful.  */
12321           free (section->start);
12322           section->start = start;
12323         }
12324       section->size = size;
12325     }
12326
12327   if (section->start == NULL)
12328     return 0;
12329
12330   if (debug_displays [debug].relocate)
12331     apply_relocations ((FILE *) file, sec, section->start, section->size,
12332                        & section->reloc_info, & section->num_relocs);
12333   else
12334     {
12335       section->reloc_info = NULL;
12336       section->num_relocs = 0;
12337     }
12338
12339   return 1;
12340 }
12341
12342 /* If this is not NULL, load_debug_section will only look for sections
12343    within the list of sections given here.  */
12344 unsigned int *section_subset = NULL;
12345
12346 int
12347 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12348 {
12349   struct dwarf_section * section = &debug_displays [debug].section;
12350   Elf_Internal_Shdr * sec;
12351
12352   /* Locate the debug section.  */
12353   sec = find_section_in_set (section->uncompressed_name, section_subset);
12354   if (sec != NULL)
12355     section->name = section->uncompressed_name;
12356   else
12357     {
12358       sec = find_section_in_set (section->compressed_name, section_subset);
12359       if (sec != NULL)
12360         section->name = section->compressed_name;
12361     }
12362   if (sec == NULL)
12363     return 0;
12364
12365   /* If we're loading from a subset of sections, and we've loaded
12366      a section matching this name before, it's likely that it's a
12367      different one.  */
12368   if (section_subset != NULL)
12369     free_debug_section (debug);
12370
12371   return load_specific_debug_section (debug, sec, (FILE *) file);
12372 }
12373
12374 void
12375 free_debug_section (enum dwarf_section_display_enum debug)
12376 {
12377   struct dwarf_section * section = &debug_displays [debug].section;
12378
12379   if (section->start == NULL)
12380     return;
12381
12382   free ((char *) section->start);
12383   section->start = NULL;
12384   section->address = 0;
12385   section->size = 0;
12386 }
12387
12388 static int
12389 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12390 {
12391   char * name = SECTION_NAME (section);
12392   const char * print_name = printable_section_name (section);
12393   bfd_size_type length;
12394   int result = 1;
12395   int i;
12396
12397   length = section->sh_size;
12398   if (length == 0)
12399     {
12400       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12401       return 0;
12402     }
12403   if (section->sh_type == SHT_NOBITS)
12404     {
12405       /* There is no point in dumping the contents of a debugging section
12406          which has the NOBITS type - the bits in the file will be random.
12407          This can happen when a file containing a .eh_frame section is
12408          stripped with the --only-keep-debug command line option.  */
12409       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12410               print_name);
12411       return 0;
12412     }
12413
12414   if (const_strneq (name, ".gnu.linkonce.wi."))
12415     name = ".debug_info";
12416
12417   /* See if we know how to display the contents of this section.  */
12418   for (i = 0; i < max; i++)
12419     if (streq (debug_displays[i].section.uncompressed_name, name)
12420         || (i == line && const_strneq (name, ".debug_line."))
12421         || streq (debug_displays[i].section.compressed_name, name))
12422       {
12423         struct dwarf_section * sec = &debug_displays [i].section;
12424         int secondary = (section != find_section (name));
12425
12426         if (secondary)
12427           free_debug_section ((enum dwarf_section_display_enum) i);
12428
12429         if (i == line && const_strneq (name, ".debug_line."))
12430           sec->name = name;
12431         else if (streq (sec->uncompressed_name, name))
12432           sec->name = sec->uncompressed_name;
12433         else
12434           sec->name = sec->compressed_name;
12435         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12436                                          section, file))
12437           {
12438             /* If this debug section is part of a CU/TU set in a .dwp file,
12439                restrict load_debug_section to the sections in that set.  */
12440             section_subset = find_cu_tu_set (file, shndx);
12441
12442             result &= debug_displays[i].display (sec, file);
12443
12444             section_subset = NULL;
12445
12446             if (secondary || (i != info && i != abbrev))
12447               free_debug_section ((enum dwarf_section_display_enum) i);
12448           }
12449
12450         break;
12451       }
12452
12453   if (i == max)
12454     {
12455       printf (_("Unrecognized debug section: %s\n"), print_name);
12456       result = 0;
12457     }
12458
12459   return result;
12460 }
12461
12462 /* Set DUMP_SECTS for all sections where dumps were requested
12463    based on section name.  */
12464
12465 static void
12466 initialise_dumps_byname (void)
12467 {
12468   struct dump_list_entry * cur;
12469
12470   for (cur = dump_sects_byname; cur; cur = cur->next)
12471     {
12472       unsigned int i;
12473       int any;
12474
12475       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12476         if (streq (SECTION_NAME (section_headers + i), cur->name))
12477           {
12478             request_dump_bynumber (i, cur->type);
12479             any = 1;
12480           }
12481
12482       if (!any)
12483         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12484               cur->name);
12485     }
12486 }
12487
12488 static void
12489 process_section_contents (FILE * file)
12490 {
12491   Elf_Internal_Shdr * section;
12492   unsigned int i;
12493
12494   if (! do_dump)
12495     return;
12496
12497   initialise_dumps_byname ();
12498
12499   for (i = 0, section = section_headers;
12500        i < elf_header.e_shnum && i < num_dump_sects;
12501        i++, section++)
12502     {
12503 #ifdef SUPPORT_DISASSEMBLY
12504       if (dump_sects[i] & DISASS_DUMP)
12505         disassemble_section (section, file);
12506 #endif
12507       if (dump_sects[i] & HEX_DUMP)
12508         dump_section_as_bytes (section, file, FALSE);
12509
12510       if (dump_sects[i] & RELOC_DUMP)
12511         dump_section_as_bytes (section, file, TRUE);
12512
12513       if (dump_sects[i] & STRING_DUMP)
12514         dump_section_as_strings (section, file);
12515
12516       if (dump_sects[i] & DEBUG_DUMP)
12517         display_debug_section (i, section, file);
12518     }
12519
12520   /* Check to see if the user requested a
12521      dump of a section that does not exist.  */
12522   while (i++ < num_dump_sects)
12523     if (dump_sects[i])
12524       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12525 }
12526
12527 static void
12528 process_mips_fpe_exception (int mask)
12529 {
12530   if (mask)
12531     {
12532       int first = 1;
12533       if (mask & OEX_FPU_INEX)
12534         fputs ("INEX", stdout), first = 0;
12535       if (mask & OEX_FPU_UFLO)
12536         printf ("%sUFLO", first ? "" : "|"), first = 0;
12537       if (mask & OEX_FPU_OFLO)
12538         printf ("%sOFLO", first ? "" : "|"), first = 0;
12539       if (mask & OEX_FPU_DIV0)
12540         printf ("%sDIV0", first ? "" : "|"), first = 0;
12541       if (mask & OEX_FPU_INVAL)
12542         printf ("%sINVAL", first ? "" : "|");
12543     }
12544   else
12545     fputs ("0", stdout);
12546 }
12547
12548 /* Display's the value of TAG at location P.  If TAG is
12549    greater than 0 it is assumed to be an unknown tag, and
12550    a message is printed to this effect.  Otherwise it is
12551    assumed that a message has already been printed.
12552
12553    If the bottom bit of TAG is set it assumed to have a
12554    string value, otherwise it is assumed to have an integer
12555    value.
12556
12557    Returns an updated P pointing to the first unread byte
12558    beyond the end of TAG's value.
12559
12560    Reads at or beyond END will not be made.  */
12561
12562 static unsigned char *
12563 display_tag_value (int tag,
12564                    unsigned char * p,
12565                    const unsigned char * const end)
12566 {
12567   unsigned long val;
12568
12569   if (tag > 0)
12570     printf ("  Tag_unknown_%d: ", tag);
12571
12572   if (p >= end)
12573     {
12574       warn (_("<corrupt tag>\n"));
12575     }
12576   else if (tag & 1)
12577     {
12578       /* PR 17531 file: 027-19978-0.004.  */
12579       size_t maxlen = (end - p) - 1;
12580
12581       putchar ('"');
12582       if (maxlen > 0)
12583         {
12584           print_symbol ((int) maxlen, (const char *) p);
12585           p += strnlen ((char *) p, maxlen) + 1;
12586         }
12587       else
12588         {
12589           printf (_("<corrupt string tag>"));
12590           p = (unsigned char *) end;
12591         }
12592       printf ("\"\n");
12593     }
12594   else
12595     {
12596       unsigned int len;
12597
12598       val = read_uleb128 (p, &len, end);
12599       p += len;
12600       printf ("%ld (0x%lx)\n", val, val);
12601     }
12602
12603   assert (p <= end);
12604   return p;
12605 }
12606
12607 /* ARM EABI attributes section.  */
12608 typedef struct
12609 {
12610   unsigned int tag;
12611   const char * name;
12612   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12613   unsigned int type;
12614   const char ** table;
12615 } arm_attr_public_tag;
12616
12617 static const char * arm_attr_tag_CPU_arch[] =
12618   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12619    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12620 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12621 static const char * arm_attr_tag_THUMB_ISA_use[] =
12622   {"No", "Thumb-1", "Thumb-2"};
12623 static const char * arm_attr_tag_FP_arch[] =
12624   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12625    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12626 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12627 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12628   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12629 static const char * arm_attr_tag_PCS_config[] =
12630   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12631    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12632 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12633   {"V6", "SB", "TLS", "Unused"};
12634 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12635   {"Absolute", "PC-relative", "SB-relative", "None"};
12636 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12637   {"Absolute", "PC-relative", "None"};
12638 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12639   {"None", "direct", "GOT-indirect"};
12640 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12641   {"None", "??? 1", "2", "??? 3", "4"};
12642 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12643 static const char * arm_attr_tag_ABI_FP_denormal[] =
12644   {"Unused", "Needed", "Sign only"};
12645 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12646 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12647 static const char * arm_attr_tag_ABI_FP_number_model[] =
12648   {"Unused", "Finite", "RTABI", "IEEE 754"};
12649 static const char * arm_attr_tag_ABI_enum_size[] =
12650   {"Unused", "small", "int", "forced to int"};
12651 static const char * arm_attr_tag_ABI_HardFP_use[] =
12652   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12653 static const char * arm_attr_tag_ABI_VFP_args[] =
12654   {"AAPCS", "VFP registers", "custom", "compatible"};
12655 static const char * arm_attr_tag_ABI_WMMX_args[] =
12656   {"AAPCS", "WMMX registers", "custom"};
12657 static const char * arm_attr_tag_ABI_optimization_goals[] =
12658   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12659     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12660 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12661   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12662     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12663 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12664 static const char * arm_attr_tag_FP_HP_extension[] =
12665   {"Not Allowed", "Allowed"};
12666 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12667   {"None", "IEEE 754", "Alternative Format"};
12668 static const char * arm_attr_tag_MPextension_use[] =
12669   {"Not Allowed", "Allowed"};
12670 static const char * arm_attr_tag_DIV_use[] =
12671   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12672     "Allowed in v7-A with integer division extension"};
12673 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12674 static const char * arm_attr_tag_Virtualization_use[] =
12675   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12676     "TrustZone and Virtualization Extensions"};
12677 static const char * arm_attr_tag_MPextension_use_legacy[] =
12678   {"Not Allowed", "Allowed"};
12679
12680 #define LOOKUP(id, name) \
12681   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12682 static arm_attr_public_tag arm_attr_public_tags[] =
12683 {
12684   {4, "CPU_raw_name", 1, NULL},
12685   {5, "CPU_name", 1, NULL},
12686   LOOKUP(6, CPU_arch),
12687   {7, "CPU_arch_profile", 0, NULL},
12688   LOOKUP(8, ARM_ISA_use),
12689   LOOKUP(9, THUMB_ISA_use),
12690   LOOKUP(10, FP_arch),
12691   LOOKUP(11, WMMX_arch),
12692   LOOKUP(12, Advanced_SIMD_arch),
12693   LOOKUP(13, PCS_config),
12694   LOOKUP(14, ABI_PCS_R9_use),
12695   LOOKUP(15, ABI_PCS_RW_data),
12696   LOOKUP(16, ABI_PCS_RO_data),
12697   LOOKUP(17, ABI_PCS_GOT_use),
12698   LOOKUP(18, ABI_PCS_wchar_t),
12699   LOOKUP(19, ABI_FP_rounding),
12700   LOOKUP(20, ABI_FP_denormal),
12701   LOOKUP(21, ABI_FP_exceptions),
12702   LOOKUP(22, ABI_FP_user_exceptions),
12703   LOOKUP(23, ABI_FP_number_model),
12704   {24, "ABI_align_needed", 0, NULL},
12705   {25, "ABI_align_preserved", 0, NULL},
12706   LOOKUP(26, ABI_enum_size),
12707   LOOKUP(27, ABI_HardFP_use),
12708   LOOKUP(28, ABI_VFP_args),
12709   LOOKUP(29, ABI_WMMX_args),
12710   LOOKUP(30, ABI_optimization_goals),
12711   LOOKUP(31, ABI_FP_optimization_goals),
12712   {32, "compatibility", 0, NULL},
12713   LOOKUP(34, CPU_unaligned_access),
12714   LOOKUP(36, FP_HP_extension),
12715   LOOKUP(38, ABI_FP_16bit_format),
12716   LOOKUP(42, MPextension_use),
12717   LOOKUP(44, DIV_use),
12718   {64, "nodefaults", 0, NULL},
12719   {65, "also_compatible_with", 0, NULL},
12720   LOOKUP(66, T2EE_use),
12721   {67, "conformance", 1, NULL},
12722   LOOKUP(68, Virtualization_use),
12723   LOOKUP(70, MPextension_use_legacy)
12724 };
12725 #undef LOOKUP
12726
12727 static unsigned char *
12728 display_arm_attribute (unsigned char * p,
12729                        const unsigned char * const end)
12730 {
12731   unsigned int tag;
12732   unsigned int len;
12733   unsigned int val;
12734   arm_attr_public_tag * attr;
12735   unsigned i;
12736   unsigned int type;
12737
12738   tag = read_uleb128 (p, &len, end);
12739   p += len;
12740   attr = NULL;
12741   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12742     {
12743       if (arm_attr_public_tags[i].tag == tag)
12744         {
12745           attr = &arm_attr_public_tags[i];
12746           break;
12747         }
12748     }
12749
12750   if (attr)
12751     {
12752       printf ("  Tag_%s: ", attr->name);
12753       switch (attr->type)
12754         {
12755         case 0:
12756           switch (tag)
12757             {
12758             case 7: /* Tag_CPU_arch_profile.  */
12759               val = read_uleb128 (p, &len, end);
12760               p += len;
12761               switch (val)
12762                 {
12763                 case 0: printf (_("None\n")); break;
12764                 case 'A': printf (_("Application\n")); break;
12765                 case 'R': printf (_("Realtime\n")); break;
12766                 case 'M': printf (_("Microcontroller\n")); break;
12767                 case 'S': printf (_("Application or Realtime\n")); break;
12768                 default: printf ("??? (%d)\n", val); break;
12769                 }
12770               break;
12771
12772             case 24: /* Tag_align_needed.  */
12773               val = read_uleb128 (p, &len, end);
12774               p += len;
12775               switch (val)
12776                 {
12777                 case 0: printf (_("None\n")); break;
12778                 case 1: printf (_("8-byte\n")); break;
12779                 case 2: printf (_("4-byte\n")); break;
12780                 case 3: printf ("??? 3\n"); break;
12781                 default:
12782                   if (val <= 12)
12783                     printf (_("8-byte and up to %d-byte extended\n"),
12784                             1 << val);
12785                   else
12786                     printf ("??? (%d)\n", val);
12787                   break;
12788                 }
12789               break;
12790
12791             case 25: /* Tag_align_preserved.  */
12792               val = read_uleb128 (p, &len, end);
12793               p += len;
12794               switch (val)
12795                 {
12796                 case 0: printf (_("None\n")); break;
12797                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12798                 case 2: printf (_("8-byte\n")); break;
12799                 case 3: printf ("??? 3\n"); break;
12800                 default:
12801                   if (val <= 12)
12802                     printf (_("8-byte and up to %d-byte extended\n"),
12803                             1 << val);
12804                   else
12805                     printf ("??? (%d)\n", val);
12806                   break;
12807                 }
12808               break;
12809
12810             case 32: /* Tag_compatibility.  */
12811               {
12812                 val = read_uleb128 (p, &len, end);
12813                 p += len;
12814                 printf (_("flag = %d, vendor = "), val);
12815                 if (p < end - 1)
12816                   {
12817                     size_t maxlen = (end - p) - 1;
12818
12819                     print_symbol ((int) maxlen, (const char *) p);
12820                     p += strnlen ((char *) p, maxlen) + 1;
12821                   }
12822                 else
12823                   {
12824                     printf (_("<corrupt>"));
12825                     p = (unsigned char *) end;
12826                   }
12827                 putchar ('\n');
12828               }
12829               break;
12830
12831             case 64: /* Tag_nodefaults.  */
12832               /* PR 17531: file: 001-505008-0.01.  */
12833               if (p < end)
12834                 p++;
12835               printf (_("True\n"));
12836               break;
12837
12838             case 65: /* Tag_also_compatible_with.  */
12839               val = read_uleb128 (p, &len, end);
12840               p += len;
12841               if (val == 6 /* Tag_CPU_arch.  */)
12842                 {
12843                   val = read_uleb128 (p, &len, end);
12844                   p += len;
12845                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12846                     printf ("??? (%d)\n", val);
12847                   else
12848                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12849                 }
12850               else
12851                 printf ("???\n");
12852               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12853                 ;
12854               break;
12855
12856             default:
12857               printf (_("<unknown: %d>\n"), tag);
12858               break;
12859             }
12860           return p;
12861
12862         case 1:
12863           return display_tag_value (-1, p, end);
12864         case 2:
12865           return display_tag_value (0, p, end);
12866
12867         default:
12868           assert (attr->type & 0x80);
12869           val = read_uleb128 (p, &len, end);
12870           p += len;
12871           type = attr->type & 0x7f;
12872           if (val >= type)
12873             printf ("??? (%d)\n", val);
12874           else
12875             printf ("%s\n", attr->table[val]);
12876           return p;
12877         }
12878     }
12879
12880   return display_tag_value (tag, p, end);
12881 }
12882
12883 static unsigned char *
12884 display_gnu_attribute (unsigned char * p,
12885                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12886                        const unsigned char * const end)
12887 {
12888   int tag;
12889   unsigned int len;
12890   int val;
12891
12892   tag = read_uleb128 (p, &len, end);
12893   p += len;
12894
12895   /* Tag_compatibility is the only generic GNU attribute defined at
12896      present.  */
12897   if (tag == 32)
12898     {
12899       val = read_uleb128 (p, &len, end);
12900       p += len;
12901
12902       printf (_("flag = %d, vendor = "), val);
12903       if (p == end)
12904         {
12905           printf (_("<corrupt>\n"));
12906           warn (_("corrupt vendor attribute\n"));
12907         }
12908       else
12909         {
12910           if (p < end - 1)
12911             {
12912               size_t maxlen = (end - p) - 1;
12913
12914               print_symbol ((int) maxlen, (const char *) p);
12915               p += strnlen ((char *) p, maxlen) + 1;
12916             }
12917           else
12918             {
12919               printf (_("<corrupt>"));
12920               p = (unsigned char *) end;
12921             }
12922           putchar ('\n');
12923         }
12924       return p;
12925     }
12926
12927   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12928     return display_proc_gnu_attribute (p, tag, end);
12929
12930   return display_tag_value (tag, p, end);
12931 }
12932
12933 static unsigned char *
12934 display_power_gnu_attribute (unsigned char * p,
12935                              int tag,
12936                              const unsigned char * const end)
12937 {
12938   unsigned int len;
12939   int val;
12940
12941   if (tag == Tag_GNU_Power_ABI_FP)
12942     {
12943       val = read_uleb128 (p, &len, end);
12944       p += len;
12945       printf ("  Tag_GNU_Power_ABI_FP: ");
12946
12947       switch (val)
12948         {
12949         case 0:
12950           printf (_("Hard or soft float\n"));
12951           break;
12952         case 1:
12953           printf (_("Hard float\n"));
12954           break;
12955         case 2:
12956           printf (_("Soft float\n"));
12957           break;
12958         case 3:
12959           printf (_("Single-precision hard float\n"));
12960           break;
12961         default:
12962           printf ("??? (%d)\n", val);
12963           break;
12964         }
12965       return p;
12966    }
12967
12968   if (tag == Tag_GNU_Power_ABI_Vector)
12969     {
12970       val = read_uleb128 (p, &len, end);
12971       p += len;
12972       printf ("  Tag_GNU_Power_ABI_Vector: ");
12973       switch (val)
12974         {
12975         case 0:
12976           printf (_("Any\n"));
12977           break;
12978         case 1:
12979           printf (_("Generic\n"));
12980           break;
12981         case 2:
12982           printf ("AltiVec\n");
12983           break;
12984         case 3:
12985           printf ("SPE\n");
12986           break;
12987         default:
12988           printf ("??? (%d)\n", val);
12989           break;
12990         }
12991       return p;
12992    }
12993
12994   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12995     {
12996       if (p == end)
12997         {
12998           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12999           return p;
13000         }
13001
13002       val = read_uleb128 (p, &len, end);
13003       p += len;
13004       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13005       switch (val)
13006        {
13007        case 0:
13008          printf (_("Any\n"));
13009          break;
13010        case 1:
13011          printf ("r3/r4\n");
13012          break;
13013        case 2:
13014          printf (_("Memory\n"));
13015          break;
13016        default:
13017          printf ("??? (%d)\n", val);
13018          break;
13019        }
13020       return p;
13021     }
13022
13023   return display_tag_value (tag & 1, p, end);
13024 }
13025
13026 static unsigned char *
13027 display_s390_gnu_attribute (unsigned char * p,
13028                             int tag,
13029                             const unsigned char * const end)
13030 {
13031   unsigned int len;
13032   int val;
13033
13034   if (tag == Tag_GNU_S390_ABI_Vector)
13035     {
13036       val = read_uleb128 (p, &len, end);
13037       p += len;
13038       printf ("  Tag_GNU_S390_ABI_Vector: ");
13039
13040       switch (val)
13041         {
13042         case 0:
13043           printf (_("any\n"));
13044           break;
13045         case 1:
13046           printf (_("software\n"));
13047           break;
13048         case 2:
13049           printf (_("hardware\n"));
13050           break;
13051         default:
13052           printf ("??? (%d)\n", val);
13053           break;
13054         }
13055       return p;
13056    }
13057
13058   return display_tag_value (tag & 1, p, end);
13059 }
13060
13061 static void
13062 display_sparc_hwcaps (int mask)
13063 {
13064   if (mask)
13065     {
13066       int first = 1;
13067
13068       if (mask & ELF_SPARC_HWCAP_MUL32)
13069         fputs ("mul32", stdout), first = 0;
13070       if (mask & ELF_SPARC_HWCAP_DIV32)
13071         printf ("%sdiv32", first ? "" : "|"), first = 0;
13072       if (mask & ELF_SPARC_HWCAP_FSMULD)
13073         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13074       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13075         printf ("%sv8plus", first ? "" : "|"), first = 0;
13076       if (mask & ELF_SPARC_HWCAP_POPC)
13077         printf ("%spopc", first ? "" : "|"), first = 0;
13078       if (mask & ELF_SPARC_HWCAP_VIS)
13079         printf ("%svis", first ? "" : "|"), first = 0;
13080       if (mask & ELF_SPARC_HWCAP_VIS2)
13081         printf ("%svis2", first ? "" : "|"), first = 0;
13082       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13083         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13084       if (mask & ELF_SPARC_HWCAP_FMAF)
13085         printf ("%sfmaf", first ? "" : "|"), first = 0;
13086       if (mask & ELF_SPARC_HWCAP_VIS3)
13087         printf ("%svis3", first ? "" : "|"), first = 0;
13088       if (mask & ELF_SPARC_HWCAP_HPC)
13089         printf ("%shpc", first ? "" : "|"), first = 0;
13090       if (mask & ELF_SPARC_HWCAP_RANDOM)
13091         printf ("%srandom", first ? "" : "|"), first = 0;
13092       if (mask & ELF_SPARC_HWCAP_TRANS)
13093         printf ("%strans", first ? "" : "|"), first = 0;
13094       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13095         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13096       if (mask & ELF_SPARC_HWCAP_IMA)
13097         printf ("%sima", first ? "" : "|"), first = 0;
13098       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13099         printf ("%scspare", first ? "" : "|"), first = 0;
13100     }
13101   else
13102     fputc ('0', stdout);
13103   fputc ('\n', stdout);
13104 }
13105
13106 static void
13107 display_sparc_hwcaps2 (int mask)
13108 {
13109   if (mask)
13110     {
13111       int first = 1;
13112
13113       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13114         fputs ("fjathplus", stdout), first = 0;
13115       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13116         printf ("%svis3b", first ? "" : "|"), first = 0;
13117       if (mask & ELF_SPARC_HWCAP2_ADP)
13118         printf ("%sadp", first ? "" : "|"), first = 0;
13119       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13120         printf ("%ssparc5", first ? "" : "|"), first = 0;
13121       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13122         printf ("%smwait", first ? "" : "|"), first = 0;
13123       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13124         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13125       if (mask & ELF_SPARC_HWCAP2_XMONT)
13126         printf ("%sxmont2", first ? "" : "|"), first = 0;
13127       if (mask & ELF_SPARC_HWCAP2_NSEC)
13128         printf ("%snsec", first ? "" : "|"), first = 0;
13129       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13130         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13131       if (mask & ELF_SPARC_HWCAP2_FJDES)
13132         printf ("%sfjdes", first ? "" : "|"), first = 0;
13133       if (mask & ELF_SPARC_HWCAP2_FJAES)
13134         printf ("%sfjaes", first ? "" : "|"), first = 0;
13135     }
13136   else
13137     fputc ('0', stdout);
13138   fputc ('\n', stdout);
13139 }
13140
13141 static unsigned char *
13142 display_sparc_gnu_attribute (unsigned char * p,
13143                              int tag,
13144                              const unsigned char * const end)
13145 {
13146   unsigned int len;
13147   int val;
13148
13149   if (tag == Tag_GNU_Sparc_HWCAPS)
13150     {
13151       val = read_uleb128 (p, &len, end);
13152       p += len;
13153       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13154       display_sparc_hwcaps (val);
13155       return p;
13156     }
13157   if (tag == Tag_GNU_Sparc_HWCAPS2)
13158     {
13159       val = read_uleb128 (p, &len, end);
13160       p += len;
13161       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13162       display_sparc_hwcaps2 (val);
13163       return p;
13164     }
13165
13166   return display_tag_value (tag, p, end);
13167 }
13168
13169 static void
13170 print_mips_fp_abi_value (int val)
13171 {
13172   switch (val)
13173     {
13174     case Val_GNU_MIPS_ABI_FP_ANY:
13175       printf (_("Hard or soft float\n"));
13176       break;
13177     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13178       printf (_("Hard float (double precision)\n"));
13179       break;
13180     case Val_GNU_MIPS_ABI_FP_SINGLE:
13181       printf (_("Hard float (single precision)\n"));
13182       break;
13183     case Val_GNU_MIPS_ABI_FP_SOFT:
13184       printf (_("Soft float\n"));
13185       break;
13186     case Val_GNU_MIPS_ABI_FP_OLD_64:
13187       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13188       break;
13189     case Val_GNU_MIPS_ABI_FP_XX:
13190       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13191       break;
13192     case Val_GNU_MIPS_ABI_FP_64:
13193       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13194       break;
13195     case Val_GNU_MIPS_ABI_FP_64A:
13196       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13197       break;
13198     default:
13199       printf ("??? (%d)\n", val);
13200       break;
13201     }
13202 }
13203
13204 static unsigned char *
13205 display_mips_gnu_attribute (unsigned char * p,
13206                             int tag,
13207                             const unsigned char * const end)
13208 {
13209   if (tag == Tag_GNU_MIPS_ABI_FP)
13210     {
13211       unsigned int len;
13212       int val;
13213
13214       val = read_uleb128 (p, &len, end);
13215       p += len;
13216       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13217
13218       print_mips_fp_abi_value (val);
13219
13220       return p;
13221    }
13222
13223   if (tag == Tag_GNU_MIPS_ABI_MSA)
13224     {
13225       unsigned int len;
13226       int val;
13227
13228       val = read_uleb128 (p, &len, end);
13229       p += len;
13230       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13231
13232       switch (val)
13233         {
13234         case Val_GNU_MIPS_ABI_MSA_ANY:
13235           printf (_("Any MSA or not\n"));
13236           break;
13237         case Val_GNU_MIPS_ABI_MSA_128:
13238           printf (_("128-bit MSA\n"));
13239           break;
13240         default:
13241           printf ("??? (%d)\n", val);
13242           break;
13243         }
13244       return p;
13245     }
13246
13247   return display_tag_value (tag & 1, p, end);
13248 }
13249
13250 static unsigned char *
13251 display_tic6x_attribute (unsigned char * p,
13252                          const unsigned char * const end)
13253 {
13254   int tag;
13255   unsigned int len;
13256   int val;
13257
13258   tag = read_uleb128 (p, &len, end);
13259   p += len;
13260
13261   switch (tag)
13262     {
13263     case Tag_ISA:
13264       val = read_uleb128 (p, &len, end);
13265       p += len;
13266       printf ("  Tag_ISA: ");
13267
13268       switch (val)
13269         {
13270         case C6XABI_Tag_ISA_none:
13271           printf (_("None\n"));
13272           break;
13273         case C6XABI_Tag_ISA_C62X:
13274           printf ("C62x\n");
13275           break;
13276         case C6XABI_Tag_ISA_C67X:
13277           printf ("C67x\n");
13278           break;
13279         case C6XABI_Tag_ISA_C67XP:
13280           printf ("C67x+\n");
13281           break;
13282         case C6XABI_Tag_ISA_C64X:
13283           printf ("C64x\n");
13284           break;
13285         case C6XABI_Tag_ISA_C64XP:
13286           printf ("C64x+\n");
13287           break;
13288         case C6XABI_Tag_ISA_C674X:
13289           printf ("C674x\n");
13290           break;
13291         default:
13292           printf ("??? (%d)\n", val);
13293           break;
13294         }
13295       return p;
13296
13297     case Tag_ABI_wchar_t:
13298       val = read_uleb128 (p, &len, end);
13299       p += len;
13300       printf ("  Tag_ABI_wchar_t: ");
13301       switch (val)
13302         {
13303         case 0:
13304           printf (_("Not used\n"));
13305           break;
13306         case 1:
13307           printf (_("2 bytes\n"));
13308           break;
13309         case 2:
13310           printf (_("4 bytes\n"));
13311           break;
13312         default:
13313           printf ("??? (%d)\n", val);
13314           break;
13315         }
13316       return p;
13317
13318     case Tag_ABI_stack_align_needed:
13319       val = read_uleb128 (p, &len, end);
13320       p += len;
13321       printf ("  Tag_ABI_stack_align_needed: ");
13322       switch (val)
13323         {
13324         case 0:
13325           printf (_("8-byte\n"));
13326           break;
13327         case 1:
13328           printf (_("16-byte\n"));
13329           break;
13330         default:
13331           printf ("??? (%d)\n", val);
13332           break;
13333         }
13334       return p;
13335
13336     case Tag_ABI_stack_align_preserved:
13337       val = read_uleb128 (p, &len, end);
13338       p += len;
13339       printf ("  Tag_ABI_stack_align_preserved: ");
13340       switch (val)
13341         {
13342         case 0:
13343           printf (_("8-byte\n"));
13344           break;
13345         case 1:
13346           printf (_("16-byte\n"));
13347           break;
13348         default:
13349           printf ("??? (%d)\n", val);
13350           break;
13351         }
13352       return p;
13353
13354     case Tag_ABI_DSBT:
13355       val = read_uleb128 (p, &len, end);
13356       p += len;
13357       printf ("  Tag_ABI_DSBT: ");
13358       switch (val)
13359         {
13360         case 0:
13361           printf (_("DSBT addressing not used\n"));
13362           break;
13363         case 1:
13364           printf (_("DSBT addressing used\n"));
13365           break;
13366         default:
13367           printf ("??? (%d)\n", val);
13368           break;
13369         }
13370       return p;
13371
13372     case Tag_ABI_PID:
13373       val = read_uleb128 (p, &len, end);
13374       p += len;
13375       printf ("  Tag_ABI_PID: ");
13376       switch (val)
13377         {
13378         case 0:
13379           printf (_("Data addressing position-dependent\n"));
13380           break;
13381         case 1:
13382           printf (_("Data addressing position-independent, GOT near DP\n"));
13383           break;
13384         case 2:
13385           printf (_("Data addressing position-independent, GOT far from DP\n"));
13386           break;
13387         default:
13388           printf ("??? (%d)\n", val);
13389           break;
13390         }
13391       return p;
13392
13393     case Tag_ABI_PIC:
13394       val = read_uleb128 (p, &len, end);
13395       p += len;
13396       printf ("  Tag_ABI_PIC: ");
13397       switch (val)
13398         {
13399         case 0:
13400           printf (_("Code addressing position-dependent\n"));
13401           break;
13402         case 1:
13403           printf (_("Code addressing position-independent\n"));
13404           break;
13405         default:
13406           printf ("??? (%d)\n", val);
13407           break;
13408         }
13409       return p;
13410
13411     case Tag_ABI_array_object_alignment:
13412       val = read_uleb128 (p, &len, end);
13413       p += len;
13414       printf ("  Tag_ABI_array_object_alignment: ");
13415       switch (val)
13416         {
13417         case 0:
13418           printf (_("8-byte\n"));
13419           break;
13420         case 1:
13421           printf (_("4-byte\n"));
13422           break;
13423         case 2:
13424           printf (_("16-byte\n"));
13425           break;
13426         default:
13427           printf ("??? (%d)\n", val);
13428           break;
13429         }
13430       return p;
13431
13432     case Tag_ABI_array_object_align_expected:
13433       val = read_uleb128 (p, &len, end);
13434       p += len;
13435       printf ("  Tag_ABI_array_object_align_expected: ");
13436       switch (val)
13437         {
13438         case 0:
13439           printf (_("8-byte\n"));
13440           break;
13441         case 1:
13442           printf (_("4-byte\n"));
13443           break;
13444         case 2:
13445           printf (_("16-byte\n"));
13446           break;
13447         default:
13448           printf ("??? (%d)\n", val);
13449           break;
13450         }
13451       return p;
13452
13453     case Tag_ABI_compatibility:
13454       {
13455         val = read_uleb128 (p, &len, end);
13456         p += len;
13457         printf ("  Tag_ABI_compatibility: ");
13458         printf (_("flag = %d, vendor = "), val);
13459         if (p < end - 1)
13460           {
13461             size_t maxlen = (end - p) - 1;
13462
13463             print_symbol ((int) maxlen, (const char *) p);
13464             p += strnlen ((char *) p, maxlen) + 1;
13465           }
13466         else
13467           {
13468             printf (_("<corrupt>"));
13469             p = (unsigned char *) end;
13470           }
13471         putchar ('\n');
13472         return p;
13473       }
13474
13475     case Tag_ABI_conformance:
13476       {
13477         printf ("  Tag_ABI_conformance: \"");
13478         if (p < end - 1)
13479           {
13480             size_t maxlen = (end - p) - 1;
13481
13482             print_symbol ((int) maxlen, (const char *) p);
13483             p += strnlen ((char *) p, maxlen) + 1;
13484           }
13485         else
13486           {
13487             printf (_("<corrupt>"));
13488             p = (unsigned char *) end;
13489           }
13490         printf ("\"\n");
13491         return p;
13492       }
13493     }
13494
13495   return display_tag_value (tag, p, end);
13496 }
13497
13498 static void
13499 display_raw_attribute (unsigned char * p, unsigned char * end)
13500 {
13501   unsigned long addr = 0;
13502   size_t bytes = end - p;
13503
13504   assert (end > p);
13505   while (bytes)
13506     {
13507       int j;
13508       int k;
13509       int lbytes = (bytes > 16 ? 16 : bytes);
13510
13511       printf ("  0x%8.8lx ", addr);
13512
13513       for (j = 0; j < 16; j++)
13514         {
13515           if (j < lbytes)
13516             printf ("%2.2x", p[j]);
13517           else
13518             printf ("  ");
13519
13520           if ((j & 3) == 3)
13521             printf (" ");
13522         }
13523
13524       for (j = 0; j < lbytes; j++)
13525         {
13526           k = p[j];
13527           if (k >= ' ' && k < 0x7f)
13528             printf ("%c", k);
13529           else
13530             printf (".");
13531         }
13532
13533       putchar ('\n');
13534
13535       p  += lbytes;
13536       bytes -= lbytes;
13537       addr += lbytes;
13538     }
13539
13540   putchar ('\n');
13541 }
13542
13543 static unsigned char *
13544 display_msp430x_attribute (unsigned char * p,
13545                            const unsigned char * const end)
13546 {
13547   unsigned int len;
13548   int val;
13549   int tag;
13550
13551   tag = read_uleb128 (p, & len, end);
13552   p += len;
13553
13554   switch (tag)
13555     {
13556     case OFBA_MSPABI_Tag_ISA:
13557       val = read_uleb128 (p, &len, end);
13558       p += len;
13559       printf ("  Tag_ISA: ");
13560       switch (val)
13561         {
13562         case 0: printf (_("None\n")); break;
13563         case 1: printf (_("MSP430\n")); break;
13564         case 2: printf (_("MSP430X\n")); break;
13565         default: printf ("??? (%d)\n", val); break;
13566         }
13567       break;
13568
13569     case OFBA_MSPABI_Tag_Code_Model:
13570       val = read_uleb128 (p, &len, end);
13571       p += len;
13572       printf ("  Tag_Code_Model: ");
13573       switch (val)
13574         {
13575         case 0: printf (_("None\n")); break;
13576         case 1: printf (_("Small\n")); break;
13577         case 2: printf (_("Large\n")); break;
13578         default: printf ("??? (%d)\n", val); break;
13579         }
13580       break;
13581
13582     case OFBA_MSPABI_Tag_Data_Model:
13583       val = read_uleb128 (p, &len, end);
13584       p += len;
13585       printf ("  Tag_Data_Model: ");
13586       switch (val)
13587         {
13588         case 0: printf (_("None\n")); break;
13589         case 1: printf (_("Small\n")); break;
13590         case 2: printf (_("Large\n")); break;
13591         case 3: printf (_("Restricted Large\n")); break;
13592         default: printf ("??? (%d)\n", val); break;
13593         }
13594       break;
13595
13596     default:
13597       printf (_("  <unknown tag %d>: "), tag);
13598
13599       if (tag & 1)
13600         {
13601           putchar ('"');
13602           if (p < end - 1)
13603             {
13604               size_t maxlen = (end - p) - 1;
13605
13606               print_symbol ((int) maxlen, (const char *) p);
13607               p += strnlen ((char *) p, maxlen) + 1;
13608             }
13609           else
13610             {
13611               printf (_("<corrupt>"));
13612               p = (unsigned char *) end;
13613             }
13614           printf ("\"\n");
13615         }
13616       else
13617         {
13618           val = read_uleb128 (p, &len, end);
13619           p += len;
13620           printf ("%d (0x%x)\n", val, val);
13621         }
13622       break;
13623    }
13624
13625   assert (p <= end);
13626   return p;
13627 }
13628
13629 static int
13630 process_attributes (FILE * file,
13631                     const char * public_name,
13632                     unsigned int proc_type,
13633                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13634                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13635 {
13636   Elf_Internal_Shdr * sect;
13637   unsigned i;
13638
13639   /* Find the section header so that we get the size.  */
13640   for (i = 0, sect = section_headers;
13641        i < elf_header.e_shnum;
13642        i++, sect++)
13643     {
13644       unsigned char * contents;
13645       unsigned char * p;
13646
13647       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13648         continue;
13649
13650       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13651                                              sect->sh_size, _("attributes"));
13652       if (contents == NULL)
13653         continue;
13654
13655       p = contents;
13656       if (*p == 'A')
13657         {
13658           bfd_vma section_len;
13659
13660           section_len = sect->sh_size - 1;
13661           p++;
13662
13663           while (section_len > 0)
13664             {
13665               bfd_vma attr_len;
13666               unsigned int namelen;
13667               bfd_boolean public_section;
13668               bfd_boolean gnu_section;
13669
13670               if (section_len <= 4)
13671                 {
13672                   error (_("Tag section ends prematurely\n"));
13673                   break;
13674                 }
13675               attr_len = byte_get (p, 4);
13676               p += 4;
13677
13678               if (attr_len > section_len)
13679                 {
13680                   error (_("Bad attribute length (%u > %u)\n"),
13681                           (unsigned) attr_len, (unsigned) section_len);
13682                   attr_len = section_len;
13683                 }
13684               /* PR 17531: file: 001-101425-0.004  */
13685               else if (attr_len < 5)
13686                 {
13687                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13688                   break;
13689                 }
13690
13691               section_len -= attr_len;
13692               attr_len -= 4;
13693
13694               namelen = strnlen ((char *) p, attr_len) + 1;
13695               if (namelen == 0 || namelen >= attr_len)
13696                 {
13697                   error (_("Corrupt attribute section name\n"));
13698                   break;
13699                 }
13700
13701               printf (_("Attribute Section: "));
13702               print_symbol (INT_MAX, (const char *) p);
13703               putchar ('\n');
13704
13705               if (public_name && streq ((char *) p, public_name))
13706                 public_section = TRUE;
13707               else
13708                 public_section = FALSE;
13709
13710               if (streq ((char *) p, "gnu"))
13711                 gnu_section = TRUE;
13712               else
13713                 gnu_section = FALSE;
13714
13715               p += namelen;
13716               attr_len -= namelen;
13717
13718               while (attr_len > 0 && p < contents + sect->sh_size)
13719                 {
13720                   int tag;
13721                   int val;
13722                   bfd_vma size;
13723                   unsigned char * end;
13724
13725                   /* PR binutils/17531: Safe handling of corrupt files.  */
13726                   if (attr_len < 6)
13727                     {
13728                       error (_("Unused bytes at end of section\n"));
13729                       section_len = 0;
13730                       break;
13731                     }
13732
13733                   tag = *(p++);
13734                   size = byte_get (p, 4);
13735                   if (size > attr_len)
13736                     {
13737                       error (_("Bad subsection length (%u > %u)\n"),
13738                               (unsigned) size, (unsigned) attr_len);
13739                       size = attr_len;
13740                     }
13741                   /* PR binutils/17531: Safe handling of corrupt files.  */
13742                   if (size < 6)
13743                     {
13744                       error (_("Bad subsection length (%u < 6)\n"),
13745                               (unsigned) size);
13746                       section_len = 0;
13747                       break;
13748                     }
13749
13750                   attr_len -= size;
13751                   end = p + size - 1;
13752                   assert (end <= contents + sect->sh_size);
13753                   p += 4;
13754
13755                   switch (tag)
13756                     {
13757                     case 1:
13758                       printf (_("File Attributes\n"));
13759                       break;
13760                     case 2:
13761                       printf (_("Section Attributes:"));
13762                       goto do_numlist;
13763                     case 3:
13764                       printf (_("Symbol Attributes:"));
13765                     do_numlist:
13766                       for (;;)
13767                         {
13768                           unsigned int j;
13769
13770                           val = read_uleb128 (p, &j, end);
13771                           p += j;
13772                           if (val == 0)
13773                             break;
13774                           printf (" %d", val);
13775                         }
13776                       printf ("\n");
13777                       break;
13778                     default:
13779                       printf (_("Unknown tag: %d\n"), tag);
13780                       public_section = FALSE;
13781                       break;
13782                     }
13783
13784                   if (public_section && display_pub_attribute != NULL)
13785                     {
13786                       while (p < end)
13787                         p = display_pub_attribute (p, end);
13788                       assert (p <= end);
13789                     }
13790                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13791                     {
13792                       while (p < end)
13793                         p = display_gnu_attribute (p,
13794                                                    display_proc_gnu_attribute,
13795                                                    end);
13796                       assert (p <= end);
13797                     }
13798                   else if (p < end)
13799                     {
13800                       printf (_("  Unknown attribute:\n"));
13801                       display_raw_attribute (p, end);
13802                       p = end;
13803                     }
13804                   else
13805                     attr_len = 0;
13806                 }
13807             }
13808         }
13809       else
13810         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13811
13812       free (contents);
13813     }
13814   return 1;
13815 }
13816
13817 static int
13818 process_arm_specific (FILE * file)
13819 {
13820   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13821                              display_arm_attribute, NULL);
13822 }
13823
13824 static int
13825 process_power_specific (FILE * file)
13826 {
13827   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13828                              display_power_gnu_attribute);
13829 }
13830
13831 static int
13832 process_s390_specific (FILE * file)
13833 {
13834   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13835                              display_s390_gnu_attribute);
13836 }
13837
13838 static int
13839 process_sparc_specific (FILE * file)
13840 {
13841   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13842                              display_sparc_gnu_attribute);
13843 }
13844
13845 static int
13846 process_tic6x_specific (FILE * file)
13847 {
13848   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13849                              display_tic6x_attribute, NULL);
13850 }
13851
13852 static int
13853 process_msp430x_specific (FILE * file)
13854 {
13855   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13856                              display_msp430x_attribute, NULL);
13857 }
13858
13859 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13860    Print the Address, Access and Initial fields of an entry at VMA ADDR
13861    and return the VMA of the next entry, or -1 if there was a problem.
13862    Does not read from DATA_END or beyond.  */
13863
13864 static bfd_vma
13865 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13866                       unsigned char * data_end)
13867 {
13868   printf ("  ");
13869   print_vma (addr, LONG_HEX);
13870   printf (" ");
13871   if (addr < pltgot + 0xfff0)
13872     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13873   else
13874     printf ("%10s", "");
13875   printf (" ");
13876   if (data == NULL)
13877     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13878   else
13879     {
13880       bfd_vma entry;
13881       unsigned char * from = data + addr - pltgot;
13882
13883       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13884         {
13885           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13886           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13887           return (bfd_vma) -1;
13888         }
13889       else
13890         {
13891           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13892           print_vma (entry, LONG_HEX);
13893         }
13894     }
13895   return addr + (is_32bit_elf ? 4 : 8);
13896 }
13897
13898 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13899    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13900    ADDR and return the VMA of the next entry.  */
13901
13902 static bfd_vma
13903 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13904 {
13905   printf ("  ");
13906   print_vma (addr, LONG_HEX);
13907   printf (" ");
13908   if (data == NULL)
13909     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13910   else
13911     {
13912       bfd_vma entry;
13913
13914       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13915       print_vma (entry, LONG_HEX);
13916     }
13917   return addr + (is_32bit_elf ? 4 : 8);
13918 }
13919
13920 static void
13921 print_mips_ases (unsigned int mask)
13922 {
13923   if (mask & AFL_ASE_DSP)
13924     fputs ("\n\tDSP ASE", stdout);
13925   if (mask & AFL_ASE_DSPR2)
13926     fputs ("\n\tDSP R2 ASE", stdout);
13927   if (mask & AFL_ASE_EVA)
13928     fputs ("\n\tEnhanced VA Scheme", stdout);
13929   if (mask & AFL_ASE_MCU)
13930     fputs ("\n\tMCU (MicroController) ASE", stdout);
13931   if (mask & AFL_ASE_MDMX)
13932     fputs ("\n\tMDMX ASE", stdout);
13933   if (mask & AFL_ASE_MIPS3D)
13934     fputs ("\n\tMIPS-3D ASE", stdout);
13935   if (mask & AFL_ASE_MT)
13936     fputs ("\n\tMT ASE", stdout);
13937   if (mask & AFL_ASE_SMARTMIPS)
13938     fputs ("\n\tSmartMIPS ASE", stdout);
13939   if (mask & AFL_ASE_VIRT)
13940     fputs ("\n\tVZ ASE", stdout);
13941   if (mask & AFL_ASE_MSA)
13942     fputs ("\n\tMSA ASE", stdout);
13943   if (mask & AFL_ASE_MIPS16)
13944     fputs ("\n\tMIPS16 ASE", stdout);
13945   if (mask & AFL_ASE_MICROMIPS)
13946     fputs ("\n\tMICROMIPS ASE", stdout);
13947   if (mask & AFL_ASE_XPA)
13948     fputs ("\n\tXPA ASE", stdout);
13949   if (mask == 0)
13950     fprintf (stdout, "\n\t%s", _("None"));
13951   else if ((mask & ~AFL_ASE_MASK) != 0)
13952     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13953 }
13954
13955 static void
13956 print_mips_isa_ext (unsigned int isa_ext)
13957 {
13958   switch (isa_ext)
13959     {
13960     case 0:
13961       fputs (_("None"), stdout);
13962       break;
13963     case AFL_EXT_XLR:
13964       fputs ("RMI XLR", stdout);
13965       break;
13966     case AFL_EXT_OCTEON3:
13967       fputs ("Cavium Networks Octeon3", stdout);
13968       break;
13969     case AFL_EXT_OCTEON2:
13970       fputs ("Cavium Networks Octeon2", stdout);
13971       break;
13972     case AFL_EXT_OCTEONP:
13973       fputs ("Cavium Networks OcteonP", stdout);
13974       break;
13975     case AFL_EXT_LOONGSON_3A:
13976       fputs ("Loongson 3A", stdout);
13977       break;
13978     case AFL_EXT_OCTEON:
13979       fputs ("Cavium Networks Octeon", stdout);
13980       break;
13981     case AFL_EXT_5900:
13982       fputs ("Toshiba R5900", stdout);
13983       break;
13984     case AFL_EXT_4650:
13985       fputs ("MIPS R4650", stdout);
13986       break;
13987     case AFL_EXT_4010:
13988       fputs ("LSI R4010", stdout);
13989       break;
13990     case AFL_EXT_4100:
13991       fputs ("NEC VR4100", stdout);
13992       break;
13993     case AFL_EXT_3900:
13994       fputs ("Toshiba R3900", stdout);
13995       break;
13996     case AFL_EXT_10000:
13997       fputs ("MIPS R10000", stdout);
13998       break;
13999     case AFL_EXT_SB1:
14000       fputs ("Broadcom SB-1", stdout);
14001       break;
14002     case AFL_EXT_4111:
14003       fputs ("NEC VR4111/VR4181", stdout);
14004       break;
14005     case AFL_EXT_4120:
14006       fputs ("NEC VR4120", stdout);
14007       break;
14008     case AFL_EXT_5400:
14009       fputs ("NEC VR5400", stdout);
14010       break;
14011     case AFL_EXT_5500:
14012       fputs ("NEC VR5500", stdout);
14013       break;
14014     case AFL_EXT_LOONGSON_2E:
14015       fputs ("ST Microelectronics Loongson 2E", stdout);
14016       break;
14017     case AFL_EXT_LOONGSON_2F:
14018       fputs ("ST Microelectronics Loongson 2F", stdout);
14019       break;
14020     default:
14021       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14022     }
14023 }
14024
14025 static int
14026 get_mips_reg_size (int reg_size)
14027 {
14028   return (reg_size == AFL_REG_NONE) ? 0
14029          : (reg_size == AFL_REG_32) ? 32
14030          : (reg_size == AFL_REG_64) ? 64
14031          : (reg_size == AFL_REG_128) ? 128
14032          : -1;
14033 }
14034
14035 static int
14036 process_mips_specific (FILE * file)
14037 {
14038   Elf_Internal_Dyn * entry;
14039   Elf_Internal_Shdr *sect = NULL;
14040   size_t liblist_offset = 0;
14041   size_t liblistno = 0;
14042   size_t conflictsno = 0;
14043   size_t options_offset = 0;
14044   size_t conflicts_offset = 0;
14045   size_t pltrelsz = 0;
14046   size_t pltrel = 0;
14047   bfd_vma pltgot = 0;
14048   bfd_vma mips_pltgot = 0;
14049   bfd_vma jmprel = 0;
14050   bfd_vma local_gotno = 0;
14051   bfd_vma gotsym = 0;
14052   bfd_vma symtabno = 0;
14053
14054   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14055                       display_mips_gnu_attribute);
14056
14057   sect = find_section (".MIPS.abiflags");
14058
14059   if (sect != NULL)
14060     {
14061       Elf_External_ABIFlags_v0 *abiflags_ext;
14062       Elf_Internal_ABIFlags_v0 abiflags_in;
14063
14064       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14065         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14066       else
14067         {
14068           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14069                                    sect->sh_size, _("MIPS ABI Flags section"));
14070           if (abiflags_ext)
14071             {
14072               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14073               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14074               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14075               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14076               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14077               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14078               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14079               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14080               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14081               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14082               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14083
14084               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14085               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14086               if (abiflags_in.isa_rev > 1)
14087                 printf ("r%d", abiflags_in.isa_rev);
14088               printf ("\nGPR size: %d",
14089                       get_mips_reg_size (abiflags_in.gpr_size));
14090               printf ("\nCPR1 size: %d",
14091                       get_mips_reg_size (abiflags_in.cpr1_size));
14092               printf ("\nCPR2 size: %d",
14093                       get_mips_reg_size (abiflags_in.cpr2_size));
14094               fputs ("\nFP ABI: ", stdout);
14095               print_mips_fp_abi_value (abiflags_in.fp_abi);
14096               fputs ("ISA Extension: ", stdout);
14097               print_mips_isa_ext (abiflags_in.isa_ext);
14098               fputs ("\nASEs:", stdout);
14099               print_mips_ases (abiflags_in.ases);
14100               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14101               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14102               fputc ('\n', stdout);
14103               free (abiflags_ext);
14104             }
14105         }
14106     }
14107
14108   /* We have a lot of special sections.  Thanks SGI!  */
14109   if (dynamic_section == NULL)
14110     /* No information available.  */
14111     return 0;
14112
14113   for (entry = dynamic_section;
14114        /* PR 17531 file: 012-50589-0.004.  */
14115        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14116        ++entry)
14117     switch (entry->d_tag)
14118       {
14119       case DT_MIPS_LIBLIST:
14120         liblist_offset
14121           = offset_from_vma (file, entry->d_un.d_val,
14122                              liblistno * sizeof (Elf32_External_Lib));
14123         break;
14124       case DT_MIPS_LIBLISTNO:
14125         liblistno = entry->d_un.d_val;
14126         break;
14127       case DT_MIPS_OPTIONS:
14128         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14129         break;
14130       case DT_MIPS_CONFLICT:
14131         conflicts_offset
14132           = offset_from_vma (file, entry->d_un.d_val,
14133                              conflictsno * sizeof (Elf32_External_Conflict));
14134         break;
14135       case DT_MIPS_CONFLICTNO:
14136         conflictsno = entry->d_un.d_val;
14137         break;
14138       case DT_PLTGOT:
14139         pltgot = entry->d_un.d_ptr;
14140         break;
14141       case DT_MIPS_LOCAL_GOTNO:
14142         local_gotno = entry->d_un.d_val;
14143         break;
14144       case DT_MIPS_GOTSYM:
14145         gotsym = entry->d_un.d_val;
14146         break;
14147       case DT_MIPS_SYMTABNO:
14148         symtabno = entry->d_un.d_val;
14149         break;
14150       case DT_MIPS_PLTGOT:
14151         mips_pltgot = entry->d_un.d_ptr;
14152         break;
14153       case DT_PLTREL:
14154         pltrel = entry->d_un.d_val;
14155         break;
14156       case DT_PLTRELSZ:
14157         pltrelsz = entry->d_un.d_val;
14158         break;
14159       case DT_JMPREL:
14160         jmprel = entry->d_un.d_ptr;
14161         break;
14162       default:
14163         break;
14164       }
14165
14166   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14167     {
14168       Elf32_External_Lib * elib;
14169       size_t cnt;
14170
14171       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14172                                               liblistno,
14173                                               sizeof (Elf32_External_Lib),
14174                                               _("liblist section data"));
14175       if (elib)
14176         {
14177           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14178                   (unsigned long) liblistno);
14179           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14180                  stdout);
14181
14182           for (cnt = 0; cnt < liblistno; ++cnt)
14183             {
14184               Elf32_Lib liblist;
14185               time_t atime;
14186               char timebuf[20];
14187               struct tm * tmp;
14188
14189               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14190               atime = BYTE_GET (elib[cnt].l_time_stamp);
14191               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14192               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14193               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14194
14195               tmp = gmtime (&atime);
14196               snprintf (timebuf, sizeof (timebuf),
14197                         "%04u-%02u-%02uT%02u:%02u:%02u",
14198                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14199                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14200
14201               printf ("%3lu: ", (unsigned long) cnt);
14202               if (VALID_DYNAMIC_NAME (liblist.l_name))
14203                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14204               else
14205                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14206               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14207                       liblist.l_version);
14208
14209               if (liblist.l_flags == 0)
14210                 puts (_(" NONE"));
14211               else
14212                 {
14213                   static const struct
14214                   {
14215                     const char * name;
14216                     int bit;
14217                   }
14218                   l_flags_vals[] =
14219                   {
14220                     { " EXACT_MATCH", LL_EXACT_MATCH },
14221                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14222                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14223                     { " EXPORTS", LL_EXPORTS },
14224                     { " DELAY_LOAD", LL_DELAY_LOAD },
14225                     { " DELTA", LL_DELTA }
14226                   };
14227                   int flags = liblist.l_flags;
14228                   size_t fcnt;
14229
14230                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14231                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14232                       {
14233                         fputs (l_flags_vals[fcnt].name, stdout);
14234                         flags ^= l_flags_vals[fcnt].bit;
14235                       }
14236                   if (flags != 0)
14237                     printf (" %#x", (unsigned int) flags);
14238
14239                   puts ("");
14240                 }
14241             }
14242
14243           free (elib);
14244         }
14245     }
14246
14247   if (options_offset != 0)
14248     {
14249       Elf_External_Options * eopt;
14250       Elf_Internal_Options * iopt;
14251       Elf_Internal_Options * option;
14252       size_t offset;
14253       int cnt;
14254       sect = section_headers;
14255
14256       /* Find the section header so that we get the size.  */
14257       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14258       /* PR 17533 file: 012-277276-0.004.  */
14259       if (sect == NULL)
14260         {
14261           error (_("No MIPS_OPTIONS header found\n"));
14262           return 0;
14263         }
14264
14265       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14266                                                 sect->sh_size, _("options"));
14267       if (eopt)
14268         {
14269           iopt = (Elf_Internal_Options *)
14270               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14271           if (iopt == NULL)
14272             {
14273               error (_("Out of memory allocatinf space for MIPS options\n"));
14274               return 0;
14275             }
14276
14277           offset = cnt = 0;
14278           option = iopt;
14279
14280           while (offset <= sect->sh_size - sizeof (* eopt))
14281             {
14282               Elf_External_Options * eoption;
14283
14284               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14285
14286               option->kind = BYTE_GET (eoption->kind);
14287               option->size = BYTE_GET (eoption->size);
14288               option->section = BYTE_GET (eoption->section);
14289               option->info = BYTE_GET (eoption->info);
14290
14291               /* PR 17531: file: ffa0fa3b.  */
14292               if (option->size < sizeof (* eopt)
14293                   || offset + option->size > sect->sh_size)
14294                 {
14295                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14296                   return 0;
14297                 }
14298               offset += option->size;
14299
14300               ++option;
14301               ++cnt;
14302             }
14303
14304           printf (_("\nSection '%s' contains %d entries:\n"),
14305                   printable_section_name (sect), cnt);
14306
14307           option = iopt;
14308           offset = 0;
14309
14310           while (cnt-- > 0)
14311             {
14312               size_t len;
14313
14314               switch (option->kind)
14315                 {
14316                 case ODK_NULL:
14317                   /* This shouldn't happen.  */
14318                   printf (" NULL       %d %lx", option->section, option->info);
14319                   break;
14320                 case ODK_REGINFO:
14321                   printf (" REGINFO    ");
14322                   if (elf_header.e_machine == EM_MIPS)
14323                     {
14324                       /* 32bit form.  */
14325                       Elf32_External_RegInfo * ereg;
14326                       Elf32_RegInfo reginfo;
14327
14328                       ereg = (Elf32_External_RegInfo *) (option + 1);
14329                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14330                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14331                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14332                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14333                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14334                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14335
14336                       printf ("GPR %08lx  GP 0x%lx\n",
14337                               reginfo.ri_gprmask,
14338                               (unsigned long) reginfo.ri_gp_value);
14339                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14340                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14341                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14342                     }
14343                   else
14344                     {
14345                       /* 64 bit form.  */
14346                       Elf64_External_RegInfo * ereg;
14347                       Elf64_Internal_RegInfo reginfo;
14348
14349                       ereg = (Elf64_External_RegInfo *) (option + 1);
14350                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14351                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14352                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14353                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14354                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14355                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14356
14357                       printf ("GPR %08lx  GP 0x",
14358                               reginfo.ri_gprmask);
14359                       printf_vma (reginfo.ri_gp_value);
14360                       printf ("\n");
14361
14362                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14363                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14364                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14365                     }
14366                   ++option;
14367                   continue;
14368                 case ODK_EXCEPTIONS:
14369                   fputs (" EXCEPTIONS fpe_min(", stdout);
14370                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14371                   fputs (") fpe_max(", stdout);
14372                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14373                   fputs (")", stdout);
14374
14375                   if (option->info & OEX_PAGE0)
14376                     fputs (" PAGE0", stdout);
14377                   if (option->info & OEX_SMM)
14378                     fputs (" SMM", stdout);
14379                   if (option->info & OEX_FPDBUG)
14380                     fputs (" FPDBUG", stdout);
14381                   if (option->info & OEX_DISMISS)
14382                     fputs (" DISMISS", stdout);
14383                   break;
14384                 case ODK_PAD:
14385                   fputs (" PAD       ", stdout);
14386                   if (option->info & OPAD_PREFIX)
14387                     fputs (" PREFIX", stdout);
14388                   if (option->info & OPAD_POSTFIX)
14389                     fputs (" POSTFIX", stdout);
14390                   if (option->info & OPAD_SYMBOL)
14391                     fputs (" SYMBOL", stdout);
14392                   break;
14393                 case ODK_HWPATCH:
14394                   fputs (" HWPATCH   ", stdout);
14395                   if (option->info & OHW_R4KEOP)
14396                     fputs (" R4KEOP", stdout);
14397                   if (option->info & OHW_R8KPFETCH)
14398                     fputs (" R8KPFETCH", stdout);
14399                   if (option->info & OHW_R5KEOP)
14400                     fputs (" R5KEOP", stdout);
14401                   if (option->info & OHW_R5KCVTL)
14402                     fputs (" R5KCVTL", stdout);
14403                   break;
14404                 case ODK_FILL:
14405                   fputs (" FILL       ", stdout);
14406                   /* XXX Print content of info word?  */
14407                   break;
14408                 case ODK_TAGS:
14409                   fputs (" TAGS       ", stdout);
14410                   /* XXX Print content of info word?  */
14411                   break;
14412                 case ODK_HWAND:
14413                   fputs (" HWAND     ", stdout);
14414                   if (option->info & OHWA0_R4KEOP_CHECKED)
14415                     fputs (" R4KEOP_CHECKED", stdout);
14416                   if (option->info & OHWA0_R4KEOP_CLEAN)
14417                     fputs (" R4KEOP_CLEAN", stdout);
14418                   break;
14419                 case ODK_HWOR:
14420                   fputs (" HWOR      ", stdout);
14421                   if (option->info & OHWA0_R4KEOP_CHECKED)
14422                     fputs (" R4KEOP_CHECKED", stdout);
14423                   if (option->info & OHWA0_R4KEOP_CLEAN)
14424                     fputs (" R4KEOP_CLEAN", stdout);
14425                   break;
14426                 case ODK_GP_GROUP:
14427                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14428                           option->info & OGP_GROUP,
14429                           (option->info & OGP_SELF) >> 16);
14430                   break;
14431                 case ODK_IDENT:
14432                   printf (" IDENT     %#06lx  self-contained %#06lx",
14433                           option->info & OGP_GROUP,
14434                           (option->info & OGP_SELF) >> 16);
14435                   break;
14436                 default:
14437                   /* This shouldn't happen.  */
14438                   printf (" %3d ???     %d %lx",
14439                           option->kind, option->section, option->info);
14440                   break;
14441                 }
14442
14443               len = sizeof (* eopt);
14444               while (len < option->size)
14445                 {
14446                   char datum = * ((char *) eopt + offset + len);
14447
14448                   if (ISPRINT (datum))
14449                     printf ("%c", datum);
14450                   else
14451                     printf ("\\%03o", datum);
14452                   len ++;
14453                 }
14454               fputs ("\n", stdout);
14455
14456               offset += option->size;
14457               ++option;
14458             }
14459
14460           free (eopt);
14461         }
14462     }
14463
14464   if (conflicts_offset != 0 && conflictsno != 0)
14465     {
14466       Elf32_Conflict * iconf;
14467       size_t cnt;
14468
14469       if (dynamic_symbols == NULL)
14470         {
14471           error (_("conflict list found without a dynamic symbol table\n"));
14472           return 0;
14473         }
14474
14475       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14476       if (iconf == NULL)
14477         {
14478           error (_("Out of memory allocating space for dynamic conflicts\n"));
14479           return 0;
14480         }
14481
14482       if (is_32bit_elf)
14483         {
14484           Elf32_External_Conflict * econf32;
14485
14486           econf32 = (Elf32_External_Conflict *)
14487               get_data (NULL, file, conflicts_offset, conflictsno,
14488                         sizeof (* econf32), _("conflict"));
14489           if (!econf32)
14490             return 0;
14491
14492           for (cnt = 0; cnt < conflictsno; ++cnt)
14493             iconf[cnt] = BYTE_GET (econf32[cnt]);
14494
14495           free (econf32);
14496         }
14497       else
14498         {
14499           Elf64_External_Conflict * econf64;
14500
14501           econf64 = (Elf64_External_Conflict *)
14502               get_data (NULL, file, conflicts_offset, conflictsno,
14503                         sizeof (* econf64), _("conflict"));
14504           if (!econf64)
14505             return 0;
14506
14507           for (cnt = 0; cnt < conflictsno; ++cnt)
14508             iconf[cnt] = BYTE_GET (econf64[cnt]);
14509
14510           free (econf64);
14511         }
14512
14513       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14514               (unsigned long) conflictsno);
14515       puts (_("  Num:    Index       Value  Name"));
14516
14517       for (cnt = 0; cnt < conflictsno; ++cnt)
14518         {
14519           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14520
14521           if (iconf[cnt] >= num_dynamic_syms)
14522             printf (_("<corrupt symbol index>"));
14523           else
14524             {
14525               Elf_Internal_Sym * psym;
14526
14527               psym = & dynamic_symbols[iconf[cnt]];
14528               print_vma (psym->st_value, FULL_HEX);
14529               putchar (' ');
14530               if (VALID_DYNAMIC_NAME (psym->st_name))
14531                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14532               else
14533                 printf (_("<corrupt: %14ld>"), psym->st_name);
14534             }
14535           putchar ('\n');
14536         }
14537
14538       free (iconf);
14539     }
14540
14541   if (pltgot != 0 && local_gotno != 0)
14542     {
14543       bfd_vma ent, local_end, global_end;
14544       size_t i, offset;
14545       unsigned char * data;
14546       unsigned char * data_end;
14547       int addr_size;
14548
14549       ent = pltgot;
14550       addr_size = (is_32bit_elf ? 4 : 8);
14551       local_end = pltgot + local_gotno * addr_size;
14552
14553       /* PR binutils/17533 file: 012-111227-0.004  */
14554       if (symtabno < gotsym)
14555         {
14556           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14557                  (unsigned long) gotsym, (unsigned long) symtabno);
14558           return 0;
14559         }
14560
14561       global_end = local_end + (symtabno - gotsym) * addr_size;
14562       /* PR 17531: file: 54c91a34.  */
14563       if (global_end < local_end)
14564         {
14565           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14566           return 0;
14567         }
14568
14569       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14570       data = (unsigned char *) get_data (NULL, file, offset,
14571                                          global_end - pltgot, 1,
14572                                          _("Global Offset Table data"));
14573       if (data == NULL)
14574         return 0;
14575       data_end = data + (global_end - pltgot);
14576
14577       printf (_("\nPrimary GOT:\n"));
14578       printf (_(" Canonical gp value: "));
14579       print_vma (pltgot + 0x7ff0, LONG_HEX);
14580       printf ("\n\n");
14581
14582       printf (_(" Reserved entries:\n"));
14583       printf (_("  %*s %10s %*s Purpose\n"),
14584               addr_size * 2, _("Address"), _("Access"),
14585               addr_size * 2, _("Initial"));
14586       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14587       printf (_(" Lazy resolver\n"));
14588       if (ent == (bfd_vma) -1)
14589         goto got_print_fail;
14590       if (data
14591           && (byte_get (data + ent - pltgot, addr_size)
14592               >> (addr_size * 8 - 1)) != 0)
14593         {
14594           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14595           printf (_(" Module pointer (GNU extension)\n"));
14596           if (ent == (bfd_vma) -1)
14597             goto got_print_fail;
14598         }
14599       printf ("\n");
14600
14601       if (ent < local_end)
14602         {
14603           printf (_(" Local entries:\n"));
14604           printf ("  %*s %10s %*s\n",
14605                   addr_size * 2, _("Address"), _("Access"),
14606                   addr_size * 2, _("Initial"));
14607           while (ent < local_end)
14608             {
14609               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14610               printf ("\n");
14611               if (ent == (bfd_vma) -1)
14612                 goto got_print_fail;
14613             }
14614           printf ("\n");
14615         }
14616
14617       if (gotsym < symtabno)
14618         {
14619           int sym_width;
14620
14621           printf (_(" Global entries:\n"));
14622           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14623                   addr_size * 2, _("Address"),
14624                   _("Access"),
14625                   addr_size * 2, _("Initial"),
14626                   addr_size * 2, _("Sym.Val."),
14627                   _("Type"),
14628                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14629                   _("Ndx"), _("Name"));
14630
14631           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14632
14633           for (i = gotsym; i < symtabno; i++)
14634             {
14635               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14636               printf (" ");
14637
14638               if (dynamic_symbols == NULL)
14639                 printf (_("<no dynamic symbols>"));
14640               else if (i < num_dynamic_syms)
14641                 {
14642                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14643
14644                   print_vma (psym->st_value, LONG_HEX);
14645                   printf (" %-7s %3s ",
14646                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14647                           get_symbol_index_type (psym->st_shndx));
14648
14649                   if (VALID_DYNAMIC_NAME (psym->st_name))
14650                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14651                   else
14652                     printf (_("<corrupt: %14ld>"), psym->st_name);
14653                 }
14654               else
14655                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14656                         (unsigned long) i);
14657
14658               printf ("\n");
14659               if (ent == (bfd_vma) -1)
14660                 break;
14661             }
14662           printf ("\n");
14663         }
14664
14665     got_print_fail:
14666       if (data)
14667         free (data);
14668     }
14669
14670   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14671     {
14672       bfd_vma ent, end;
14673       size_t offset, rel_offset;
14674       unsigned long count, i;
14675       unsigned char * data;
14676       int addr_size, sym_width;
14677       Elf_Internal_Rela * rels;
14678
14679       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14680       if (pltrel == DT_RELA)
14681         {
14682           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14683             return 0;
14684         }
14685       else
14686         {
14687           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14688             return 0;
14689         }
14690
14691       ent = mips_pltgot;
14692       addr_size = (is_32bit_elf ? 4 : 8);
14693       end = mips_pltgot + (2 + count) * addr_size;
14694
14695       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14696       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14697                                          1, _("Procedure Linkage Table data"));
14698       if (data == NULL)
14699         return 0;
14700
14701       printf ("\nPLT GOT:\n\n");
14702       printf (_(" Reserved entries:\n"));
14703       printf (_("  %*s %*s Purpose\n"),
14704               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14705       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14706       printf (_(" PLT lazy resolver\n"));
14707       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14708       printf (_(" Module pointer\n"));
14709       printf ("\n");
14710
14711       printf (_(" Entries:\n"));
14712       printf ("  %*s %*s %*s %-7s %3s %s\n",
14713               addr_size * 2, _("Address"),
14714               addr_size * 2, _("Initial"),
14715               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14716       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14717       for (i = 0; i < count; i++)
14718         {
14719           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14720
14721           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14722           printf (" ");
14723
14724           if (idx >= num_dynamic_syms)
14725             printf (_("<corrupt symbol index: %lu>"), idx);
14726           else
14727             {
14728               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14729
14730               print_vma (psym->st_value, LONG_HEX);
14731               printf (" %-7s %3s ",
14732                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14733                       get_symbol_index_type (psym->st_shndx));
14734               if (VALID_DYNAMIC_NAME (psym->st_name))
14735                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14736               else
14737                 printf (_("<corrupt: %14ld>"), psym->st_name);
14738             }
14739           printf ("\n");
14740         }
14741       printf ("\n");
14742
14743       if (data)
14744         free (data);
14745       free (rels);
14746     }
14747
14748   return 1;
14749 }
14750
14751 static int
14752 process_nds32_specific (FILE * file)
14753 {
14754   Elf_Internal_Shdr *sect = NULL;
14755
14756   sect = find_section (".nds32_e_flags");
14757   if (sect != NULL)
14758     {
14759       unsigned int *flag;
14760
14761       printf ("\nNDS32 elf flags section:\n");
14762       flag = get_data (NULL, file, sect->sh_offset, 1,
14763                        sect->sh_size, _("NDS32 elf flags section"));
14764
14765       switch ((*flag) & 0x3)
14766         {
14767         case 0:
14768           printf ("(VEC_SIZE):\tNo entry.\n");
14769           break;
14770         case 1:
14771           printf ("(VEC_SIZE):\t4 bytes\n");
14772           break;
14773         case 2:
14774           printf ("(VEC_SIZE):\t16 bytes\n");
14775           break;
14776         case 3:
14777           printf ("(VEC_SIZE):\treserved\n");
14778           break;
14779         }
14780     }
14781
14782   return TRUE;
14783 }
14784
14785 static int
14786 process_gnu_liblist (FILE * file)
14787 {
14788   Elf_Internal_Shdr * section;
14789   Elf_Internal_Shdr * string_sec;
14790   Elf32_External_Lib * elib;
14791   char * strtab;
14792   size_t strtab_size;
14793   size_t cnt;
14794   unsigned i;
14795
14796   if (! do_arch)
14797     return 0;
14798
14799   for (i = 0, section = section_headers;
14800        i < elf_header.e_shnum;
14801        i++, section++)
14802     {
14803       switch (section->sh_type)
14804         {
14805         case SHT_GNU_LIBLIST:
14806           if (section->sh_link >= elf_header.e_shnum)
14807             break;
14808
14809           elib = (Elf32_External_Lib *)
14810               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14811                         _("liblist section data"));
14812
14813           if (elib == NULL)
14814             break;
14815           string_sec = section_headers + section->sh_link;
14816
14817           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14818                                       string_sec->sh_size,
14819                                       _("liblist string table"));
14820           if (strtab == NULL
14821               || section->sh_entsize != sizeof (Elf32_External_Lib))
14822             {
14823               free (elib);
14824               free (strtab);
14825               break;
14826             }
14827           strtab_size = string_sec->sh_size;
14828
14829           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14830                   printable_section_name (section),
14831                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14832
14833           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14834
14835           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14836                ++cnt)
14837             {
14838               Elf32_Lib liblist;
14839               time_t atime;
14840               char timebuf[20];
14841               struct tm * tmp;
14842
14843               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14844               atime = BYTE_GET (elib[cnt].l_time_stamp);
14845               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14846               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14847               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14848
14849               tmp = gmtime (&atime);
14850               snprintf (timebuf, sizeof (timebuf),
14851                         "%04u-%02u-%02uT%02u:%02u:%02u",
14852                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14853                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14854
14855               printf ("%3lu: ", (unsigned long) cnt);
14856               if (do_wide)
14857                 printf ("%-20s", liblist.l_name < strtab_size
14858                         ? strtab + liblist.l_name : _("<corrupt>"));
14859               else
14860                 printf ("%-20.20s", liblist.l_name < strtab_size
14861                         ? strtab + liblist.l_name : _("<corrupt>"));
14862               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14863                       liblist.l_version, liblist.l_flags);
14864             }
14865
14866           free (elib);
14867           free (strtab);
14868         }
14869     }
14870
14871   return 1;
14872 }
14873
14874 static const char *
14875 get_note_type (unsigned e_type)
14876 {
14877   static char buff[64];
14878
14879   if (elf_header.e_type == ET_CORE)
14880     switch (e_type)
14881       {
14882       case NT_AUXV:
14883         return _("NT_AUXV (auxiliary vector)");
14884       case NT_PRSTATUS:
14885         return _("NT_PRSTATUS (prstatus structure)");
14886       case NT_FPREGSET:
14887         return _("NT_FPREGSET (floating point registers)");
14888       case NT_PRPSINFO:
14889         return _("NT_PRPSINFO (prpsinfo structure)");
14890       case NT_TASKSTRUCT:
14891         return _("NT_TASKSTRUCT (task structure)");
14892       case NT_PRXFPREG:
14893         return _("NT_PRXFPREG (user_xfpregs structure)");
14894       case NT_PPC_VMX:
14895         return _("NT_PPC_VMX (ppc Altivec registers)");
14896       case NT_PPC_VSX:
14897         return _("NT_PPC_VSX (ppc VSX registers)");
14898       case NT_386_TLS:
14899         return _("NT_386_TLS (x86 TLS information)");
14900       case NT_386_IOPERM:
14901         return _("NT_386_IOPERM (x86 I/O permissions)");
14902       case NT_X86_XSTATE:
14903         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14904       case NT_S390_HIGH_GPRS:
14905         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14906       case NT_S390_TIMER:
14907         return _("NT_S390_TIMER (s390 timer register)");
14908       case NT_S390_TODCMP:
14909         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14910       case NT_S390_TODPREG:
14911         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14912       case NT_S390_CTRS:
14913         return _("NT_S390_CTRS (s390 control registers)");
14914       case NT_S390_PREFIX:
14915         return _("NT_S390_PREFIX (s390 prefix register)");
14916       case NT_S390_LAST_BREAK:
14917         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14918       case NT_S390_SYSTEM_CALL:
14919         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14920       case NT_S390_TDB:
14921         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14922       case NT_S390_VXRS_LOW:
14923         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14924       case NT_S390_VXRS_HIGH:
14925         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14926       case NT_ARM_VFP:
14927         return _("NT_ARM_VFP (arm VFP registers)");
14928       case NT_ARM_TLS:
14929         return _("NT_ARM_TLS (AArch TLS registers)");
14930       case NT_ARM_HW_BREAK:
14931         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14932       case NT_ARM_HW_WATCH:
14933         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14934       case NT_PSTATUS:
14935         return _("NT_PSTATUS (pstatus structure)");
14936       case NT_FPREGS:
14937         return _("NT_FPREGS (floating point registers)");
14938       case NT_PSINFO:
14939         return _("NT_PSINFO (psinfo structure)");
14940       case NT_LWPSTATUS:
14941         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14942       case NT_LWPSINFO:
14943         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14944       case NT_WIN32PSTATUS:
14945         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14946       case NT_SIGINFO:
14947         return _("NT_SIGINFO (siginfo_t data)");
14948       case NT_FILE:
14949         return _("NT_FILE (mapped files)");
14950       default:
14951         break;
14952       }
14953   else
14954     switch (e_type)
14955       {
14956       case NT_VERSION:
14957         return _("NT_VERSION (version)");
14958       case NT_ARCH:
14959         return _("NT_ARCH (architecture)");
14960       default:
14961         break;
14962       }
14963
14964   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14965   return buff;
14966 }
14967
14968 static int
14969 print_core_note (Elf_Internal_Note *pnote)
14970 {
14971   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14972   bfd_vma count, page_size;
14973   unsigned char *descdata, *filenames, *descend;
14974
14975   if (pnote->type != NT_FILE)
14976     return 1;
14977
14978 #ifndef BFD64
14979   if (!is_32bit_elf)
14980     {
14981       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14982       /* Still "successful".  */
14983       return 1;
14984     }
14985 #endif
14986
14987   if (pnote->descsz < 2 * addr_size)
14988     {
14989       printf (_("    Malformed note - too short for header\n"));
14990       return 0;
14991     }
14992
14993   descdata = (unsigned char *) pnote->descdata;
14994   descend = descdata + pnote->descsz;
14995
14996   if (descdata[pnote->descsz - 1] != '\0')
14997     {
14998       printf (_("    Malformed note - does not end with \\0\n"));
14999       return 0;
15000     }
15001
15002   count = byte_get (descdata, addr_size);
15003   descdata += addr_size;
15004
15005   page_size = byte_get (descdata, addr_size);
15006   descdata += addr_size;
15007
15008   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15009     {
15010       printf (_("    Malformed note - too short for supplied file count\n"));
15011       return 0;
15012     }
15013
15014   printf (_("    Page size: "));
15015   print_vma (page_size, DEC);
15016   printf ("\n");
15017
15018   printf (_("    %*s%*s%*s\n"),
15019           (int) (2 + 2 * addr_size), _("Start"),
15020           (int) (4 + 2 * addr_size), _("End"),
15021           (int) (4 + 2 * addr_size), _("Page Offset"));
15022   filenames = descdata + count * 3 * addr_size;
15023   while (--count > 0)
15024     {
15025       bfd_vma start, end, file_ofs;
15026
15027       if (filenames == descend)
15028         {
15029           printf (_("    Malformed note - filenames end too early\n"));
15030           return 0;
15031         }
15032
15033       start = byte_get (descdata, addr_size);
15034       descdata += addr_size;
15035       end = byte_get (descdata, addr_size);
15036       descdata += addr_size;
15037       file_ofs = byte_get (descdata, addr_size);
15038       descdata += addr_size;
15039
15040       printf ("    ");
15041       print_vma (start, FULL_HEX);
15042       printf ("  ");
15043       print_vma (end, FULL_HEX);
15044       printf ("  ");
15045       print_vma (file_ofs, FULL_HEX);
15046       printf ("\n        %s\n", filenames);
15047
15048       filenames += 1 + strlen ((char *) filenames);
15049     }
15050
15051   return 1;
15052 }
15053
15054 static const char *
15055 get_gnu_elf_note_type (unsigned e_type)
15056 {
15057   static char buff[64];
15058
15059   switch (e_type)
15060     {
15061     case NT_GNU_ABI_TAG:
15062       return _("NT_GNU_ABI_TAG (ABI version tag)");
15063     case NT_GNU_HWCAP:
15064       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15065     case NT_GNU_BUILD_ID:
15066       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15067     case NT_GNU_GOLD_VERSION:
15068       return _("NT_GNU_GOLD_VERSION (gold version)");
15069     default:
15070       break;
15071     }
15072
15073   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15074   return buff;
15075 }
15076
15077 static int
15078 print_gnu_note (Elf_Internal_Note *pnote)
15079 {
15080   switch (pnote->type)
15081     {
15082     case NT_GNU_BUILD_ID:
15083       {
15084         unsigned long i;
15085
15086         printf (_("    Build ID: "));
15087         for (i = 0; i < pnote->descsz; ++i)
15088           printf ("%02x", pnote->descdata[i] & 0xff);
15089         printf ("\n");
15090       }
15091       break;
15092
15093     case NT_GNU_ABI_TAG:
15094       {
15095         unsigned long os, major, minor, subminor;
15096         const char *osname;
15097
15098         /* PR 17531: file: 030-599401-0.004.  */
15099         if (pnote->descsz < 16)
15100           {
15101             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15102             break;
15103           }
15104
15105         os = byte_get ((unsigned char *) pnote->descdata, 4);
15106         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15107         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15108         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15109
15110         switch (os)
15111           {
15112           case GNU_ABI_TAG_LINUX:
15113             osname = "Linux";
15114             break;
15115           case GNU_ABI_TAG_HURD:
15116             osname = "Hurd";
15117             break;
15118           case GNU_ABI_TAG_SOLARIS:
15119             osname = "Solaris";
15120             break;
15121           case GNU_ABI_TAG_FREEBSD:
15122             osname = "FreeBSD";
15123             break;
15124           case GNU_ABI_TAG_NETBSD:
15125             osname = "NetBSD";
15126             break;
15127           default:
15128             osname = "Unknown";
15129             break;
15130           }
15131
15132         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15133                 major, minor, subminor);
15134       }
15135       break;
15136
15137     case NT_GNU_GOLD_VERSION:
15138       {
15139         unsigned long i;
15140
15141         printf (_("    Version: "));
15142         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15143           printf ("%c", pnote->descdata[i]);
15144         printf ("\n");
15145       }
15146       break;
15147     }
15148
15149   return 1;
15150 }
15151
15152 static const char *
15153 get_v850_elf_note_type (enum v850_notes n_type)
15154 {
15155   static char buff[64];
15156
15157   switch (n_type)
15158     {
15159     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15160     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15161     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15162     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15163     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15164     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15165     default:
15166       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15167       return buff;
15168     }
15169 }
15170
15171 static int
15172 print_v850_note (Elf_Internal_Note * pnote)
15173 {
15174   unsigned int val;
15175
15176   if (pnote->descsz != 4)
15177     return 0;
15178   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15179
15180   if (val == 0)
15181     {
15182       printf (_("not set\n"));
15183       return 1;
15184     }
15185
15186   switch (pnote->type)
15187     {
15188     case V850_NOTE_ALIGNMENT:
15189       switch (val)
15190         {
15191         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15192         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15193         }
15194       break;
15195
15196     case V850_NOTE_DATA_SIZE:
15197       switch (val)
15198         {
15199         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15200         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15201         }
15202       break;
15203
15204     case V850_NOTE_FPU_INFO:
15205       switch (val)
15206         {
15207         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15208         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15209         }
15210       break;
15211
15212     case V850_NOTE_MMU_INFO:
15213     case V850_NOTE_CACHE_INFO:
15214     case V850_NOTE_SIMD_INFO:
15215       if (val == EF_RH850_SIMD)
15216         {
15217           printf (_("yes\n"));
15218           return 1;
15219         }
15220       break;
15221
15222     default:
15223       /* An 'unknown note type' message will already have been displayed.  */
15224       break;
15225     }
15226
15227   printf (_("unknown value: %x\n"), val);
15228   return 0;
15229 }
15230
15231 static const char *
15232 get_netbsd_elfcore_note_type (unsigned e_type)
15233 {
15234   static char buff[64];
15235
15236   if (e_type == NT_NETBSDCORE_PROCINFO)
15237     {
15238       /* NetBSD core "procinfo" structure.  */
15239       return _("NetBSD procinfo structure");
15240     }
15241
15242   /* As of Jan 2002 there are no other machine-independent notes
15243      defined for NetBSD core files.  If the note type is less
15244      than the start of the machine-dependent note types, we don't
15245      understand it.  */
15246
15247   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15248     {
15249       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15250       return buff;
15251     }
15252
15253   switch (elf_header.e_machine)
15254     {
15255     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15256        and PT_GETFPREGS == mach+2.  */
15257
15258     case EM_OLD_ALPHA:
15259     case EM_ALPHA:
15260     case EM_SPARC:
15261     case EM_SPARC32PLUS:
15262     case EM_SPARCV9:
15263       switch (e_type)
15264         {
15265         case NT_NETBSDCORE_FIRSTMACH + 0:
15266           return _("PT_GETREGS (reg structure)");
15267         case NT_NETBSDCORE_FIRSTMACH + 2:
15268           return _("PT_GETFPREGS (fpreg structure)");
15269         default:
15270           break;
15271         }
15272       break;
15273
15274     /* On all other arch's, PT_GETREGS == mach+1 and
15275        PT_GETFPREGS == mach+3.  */
15276     default:
15277       switch (e_type)
15278         {
15279         case NT_NETBSDCORE_FIRSTMACH + 1:
15280           return _("PT_GETREGS (reg structure)");
15281         case NT_NETBSDCORE_FIRSTMACH + 3:
15282           return _("PT_GETFPREGS (fpreg structure)");
15283         default:
15284           break;
15285         }
15286     }
15287
15288   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15289             e_type - NT_NETBSDCORE_FIRSTMACH);
15290   return buff;
15291 }
15292
15293 static const char *
15294 get_stapsdt_note_type (unsigned e_type)
15295 {
15296   static char buff[64];
15297
15298   switch (e_type)
15299     {
15300     case NT_STAPSDT:
15301       return _("NT_STAPSDT (SystemTap probe descriptors)");
15302
15303     default:
15304       break;
15305     }
15306
15307   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15308   return buff;
15309 }
15310
15311 static int
15312 print_stapsdt_note (Elf_Internal_Note *pnote)
15313 {
15314   int addr_size = is_32bit_elf ? 4 : 8;
15315   char *data = pnote->descdata;
15316   char *data_end = pnote->descdata + pnote->descsz;
15317   bfd_vma pc, base_addr, semaphore;
15318   char *provider, *probe, *arg_fmt;
15319
15320   pc = byte_get ((unsigned char *) data, addr_size);
15321   data += addr_size;
15322   base_addr = byte_get ((unsigned char *) data, addr_size);
15323   data += addr_size;
15324   semaphore = byte_get ((unsigned char *) data, addr_size);
15325   data += addr_size;
15326
15327   provider = data;
15328   data += strlen (data) + 1;
15329   probe = data;
15330   data += strlen (data) + 1;
15331   arg_fmt = data;
15332   data += strlen (data) + 1;
15333
15334   printf (_("    Provider: %s\n"), provider);
15335   printf (_("    Name: %s\n"), probe);
15336   printf (_("    Location: "));
15337   print_vma (pc, FULL_HEX);
15338   printf (_(", Base: "));
15339   print_vma (base_addr, FULL_HEX);
15340   printf (_(", Semaphore: "));
15341   print_vma (semaphore, FULL_HEX);
15342   printf ("\n");
15343   printf (_("    Arguments: %s\n"), arg_fmt);
15344
15345   return data == data_end;
15346 }
15347
15348 static const char *
15349 get_ia64_vms_note_type (unsigned e_type)
15350 {
15351   static char buff[64];
15352
15353   switch (e_type)
15354     {
15355     case NT_VMS_MHD:
15356       return _("NT_VMS_MHD (module header)");
15357     case NT_VMS_LNM:
15358       return _("NT_VMS_LNM (language name)");
15359     case NT_VMS_SRC:
15360       return _("NT_VMS_SRC (source files)");
15361     case NT_VMS_TITLE:
15362       return "NT_VMS_TITLE";
15363     case NT_VMS_EIDC:
15364       return _("NT_VMS_EIDC (consistency check)");
15365     case NT_VMS_FPMODE:
15366       return _("NT_VMS_FPMODE (FP mode)");
15367     case NT_VMS_LINKTIME:
15368       return "NT_VMS_LINKTIME";
15369     case NT_VMS_IMGNAM:
15370       return _("NT_VMS_IMGNAM (image name)");
15371     case NT_VMS_IMGID:
15372       return _("NT_VMS_IMGID (image id)");
15373     case NT_VMS_LINKID:
15374       return _("NT_VMS_LINKID (link id)");
15375     case NT_VMS_IMGBID:
15376       return _("NT_VMS_IMGBID (build id)");
15377     case NT_VMS_GSTNAM:
15378       return _("NT_VMS_GSTNAM (sym table name)");
15379     case NT_VMS_ORIG_DYN:
15380       return "NT_VMS_ORIG_DYN";
15381     case NT_VMS_PATCHTIME:
15382       return "NT_VMS_PATCHTIME";
15383     default:
15384       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15385       return buff;
15386     }
15387 }
15388
15389 static int
15390 print_ia64_vms_note (Elf_Internal_Note * pnote)
15391 {
15392   switch (pnote->type)
15393     {
15394     case NT_VMS_MHD:
15395       if (pnote->descsz > 36)
15396         {
15397           size_t l = strlen (pnote->descdata + 34);
15398           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15399           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15400           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15401           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15402         }
15403       else
15404         printf (_("    Invalid size\n"));
15405       break;
15406     case NT_VMS_LNM:
15407       printf (_("   Language: %s\n"), pnote->descdata);
15408       break;
15409 #ifdef BFD64
15410     case NT_VMS_FPMODE:
15411       printf (_("   Floating Point mode: "));
15412       printf ("0x%016" BFD_VMA_FMT "x\n",
15413               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15414       break;
15415     case NT_VMS_LINKTIME:
15416       printf (_("   Link time: "));
15417       print_vms_time
15418         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15419       printf ("\n");
15420       break;
15421     case NT_VMS_PATCHTIME:
15422       printf (_("   Patch time: "));
15423       print_vms_time
15424         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15425       printf ("\n");
15426       break;
15427     case NT_VMS_ORIG_DYN:
15428       printf (_("   Major id: %u,  minor id: %u\n"),
15429               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15430               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15431       printf (_("   Last modified  : "));
15432       print_vms_time
15433         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15434       printf (_("\n   Link flags  : "));
15435       printf ("0x%016" BFD_VMA_FMT "x\n",
15436               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15437       printf (_("   Header flags: 0x%08x\n"),
15438               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15439       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15440       break;
15441 #endif
15442     case NT_VMS_IMGNAM:
15443       printf (_("    Image name: %s\n"), pnote->descdata);
15444       break;
15445     case NT_VMS_GSTNAM:
15446       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15447       break;
15448     case NT_VMS_IMGID:
15449       printf (_("    Image id: %s\n"), pnote->descdata);
15450       break;
15451     case NT_VMS_LINKID:
15452       printf (_("    Linker id: %s\n"), pnote->descdata);
15453       break;
15454     default:
15455       break;
15456     }
15457   return 1;
15458 }
15459
15460 /* Note that by the ELF standard, the name field is already null byte
15461    terminated, and namesz includes the terminating null byte.
15462    I.E. the value of namesz for the name "FSF" is 4.
15463
15464    If the value of namesz is zero, there is no name present.  */
15465 static int
15466 process_note (Elf_Internal_Note * pnote)
15467 {
15468   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15469   const char * nt;
15470
15471   if (pnote->namesz == 0)
15472     /* If there is no note name, then use the default set of
15473        note type strings.  */
15474     nt = get_note_type (pnote->type);
15475
15476   else if (const_strneq (pnote->namedata, "GNU"))
15477     /* GNU-specific object file notes.  */
15478     nt = get_gnu_elf_note_type (pnote->type);
15479
15480   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15481     /* NetBSD-specific core file notes.  */
15482     nt = get_netbsd_elfcore_note_type (pnote->type);
15483
15484   else if (strneq (pnote->namedata, "SPU/", 4))
15485     {
15486       /* SPU-specific core file notes.  */
15487       nt = pnote->namedata + 4;
15488       name = "SPU";
15489     }
15490
15491   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15492     /* VMS/ia64-specific file notes.  */
15493     nt = get_ia64_vms_note_type (pnote->type);
15494
15495   else if (const_strneq (pnote->namedata, "stapsdt"))
15496     nt = get_stapsdt_note_type (pnote->type);
15497
15498   else
15499     /* Don't recognize this note name; just use the default set of
15500        note type strings.  */
15501     nt = get_note_type (pnote->type);
15502
15503   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15504
15505   if (const_strneq (pnote->namedata, "IPF/VMS"))
15506     return print_ia64_vms_note (pnote);
15507   else if (const_strneq (pnote->namedata, "GNU"))
15508     return print_gnu_note (pnote);
15509   else if (const_strneq (pnote->namedata, "stapsdt"))
15510     return print_stapsdt_note (pnote);
15511   else if (const_strneq (pnote->namedata, "CORE"))
15512     return print_core_note (pnote);
15513   else
15514     return 1;
15515 }
15516
15517
15518 static int
15519 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15520 {
15521   Elf_External_Note * pnotes;
15522   Elf_External_Note * external;
15523   char * end;
15524   int res = 1;
15525
15526   if (length <= 0)
15527     return 0;
15528
15529   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15530                                            _("notes"));
15531   if (pnotes == NULL)
15532     return 0;
15533
15534   external = pnotes;
15535
15536   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15537           (unsigned long) offset, (unsigned long) length);
15538   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15539
15540   end = (char *) pnotes + length;
15541   while ((char *) external < end)
15542     {
15543       Elf_Internal_Note inote;
15544       size_t min_notesz;
15545       char *next;
15546       char * temp = NULL;
15547       size_t data_remaining = end - (char *) external;
15548
15549       if (!is_ia64_vms ())
15550         {
15551           /* PR binutils/15191
15552              Make sure that there is enough data to read.  */
15553           min_notesz = offsetof (Elf_External_Note, name);
15554           if (data_remaining < min_notesz)
15555             {
15556               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15557                     (int) data_remaining);
15558               break;
15559             }
15560           inote.type     = BYTE_GET (external->type);
15561           inote.namesz   = BYTE_GET (external->namesz);
15562           inote.namedata = external->name;
15563           inote.descsz   = BYTE_GET (external->descsz);
15564           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15565           /* PR 17531: file: 3443835e.  */
15566           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15567             {
15568               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15569               inote.descdata = inote.namedata;
15570               inote.namesz   = 0;
15571             }
15572
15573           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15574           next = inote.descdata + align_power (inote.descsz, 2);
15575         }
15576       else
15577         {
15578           Elf64_External_VMS_Note *vms_external;
15579
15580           /* PR binutils/15191
15581              Make sure that there is enough data to read.  */
15582           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15583           if (data_remaining < min_notesz)
15584             {
15585               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15586                     (int) data_remaining);
15587               break;
15588             }
15589
15590           vms_external = (Elf64_External_VMS_Note *) external;
15591           inote.type     = BYTE_GET (vms_external->type);
15592           inote.namesz   = BYTE_GET (vms_external->namesz);
15593           inote.namedata = vms_external->name;
15594           inote.descsz   = BYTE_GET (vms_external->descsz);
15595           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15596           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15597           next = inote.descdata + align_power (inote.descsz, 3);
15598         }
15599
15600       if (inote.descdata < (char *) external + min_notesz
15601           || next < (char *) external + min_notesz
15602           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15603           || inote.namedata + inote.namesz < inote.namedata
15604           || inote.descdata + inote.descsz < inote.descdata
15605           || data_remaining < (size_t)(next - (char *) external))
15606         {
15607           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15608                 (unsigned long) ((char *) external - (char *) pnotes));
15609           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15610                 inote.type, inote.namesz, inote.descsz);
15611           break;
15612         }
15613
15614       external = (Elf_External_Note *) next;
15615
15616       /* Verify that name is null terminated.  It appears that at least
15617          one version of Linux (RedHat 6.0) generates corefiles that don't
15618          comply with the ELF spec by failing to include the null byte in
15619          namesz.  */
15620       if (inote.namedata[inote.namesz - 1] != '\0')
15621         {
15622           temp = (char *) malloc (inote.namesz + 1);
15623           if (temp == NULL)
15624             {
15625               error (_("Out of memory allocating space for inote name\n"));
15626               res = 0;
15627               break;
15628             }
15629
15630           strncpy (temp, inote.namedata, inote.namesz);
15631           temp[inote.namesz] = 0;
15632
15633           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15634           inote.namedata = temp;
15635         }
15636
15637       res &= process_note (& inote);
15638
15639       if (temp != NULL)
15640         {
15641           free (temp);
15642           temp = NULL;
15643         }
15644     }
15645
15646   free (pnotes);
15647
15648   return res;
15649 }
15650
15651 static int
15652 process_corefile_note_segments (FILE * file)
15653 {
15654   Elf_Internal_Phdr * segment;
15655   unsigned int i;
15656   int res = 1;
15657
15658   if (! get_program_headers (file))
15659       return 0;
15660
15661   for (i = 0, segment = program_headers;
15662        i < elf_header.e_phnum;
15663        i++, segment++)
15664     {
15665       if (segment->p_type == PT_NOTE)
15666         res &= process_corefile_note_segment (file,
15667                                               (bfd_vma) segment->p_offset,
15668                                               (bfd_vma) segment->p_filesz);
15669     }
15670
15671   return res;
15672 }
15673
15674 static int
15675 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15676 {
15677   Elf_External_Note * pnotes;
15678   Elf_External_Note * external;
15679   char * end;
15680   int res = 1;
15681
15682   if (length <= 0)
15683     return 0;
15684
15685   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15686                                            _("v850 notes"));
15687   if (pnotes == NULL)
15688     return 0;
15689
15690   external = pnotes;
15691   end = (char*) pnotes + length;
15692
15693   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15694           (unsigned long) offset, (unsigned long) length);
15695
15696   while ((char *) external + sizeof (Elf_External_Note) < end)
15697     {
15698       Elf_External_Note * next;
15699       Elf_Internal_Note inote;
15700
15701       inote.type     = BYTE_GET (external->type);
15702       inote.namesz   = BYTE_GET (external->namesz);
15703       inote.namedata = external->name;
15704       inote.descsz   = BYTE_GET (external->descsz);
15705       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15706       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15707
15708       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15709         {
15710           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15711           inote.descdata = inote.namedata;
15712           inote.namesz   = 0;
15713         }
15714
15715       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15716
15717       if (   ((char *) next > end)
15718           || ((char *) next <  (char *) pnotes))
15719         {
15720           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15721                 (unsigned long) ((char *) external - (char *) pnotes));
15722           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15723                 inote.type, inote.namesz, inote.descsz);
15724           break;
15725         }
15726
15727       external = next;
15728
15729       /* Prevent out-of-bounds indexing.  */
15730       if (   inote.namedata + inote.namesz > end
15731           || inote.namedata + inote.namesz < inote.namedata)
15732         {
15733           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15734                 (unsigned long) ((char *) external - (char *) pnotes));
15735           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15736                 inote.type, inote.namesz, inote.descsz);
15737           break;
15738         }
15739
15740       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15741
15742       if (! print_v850_note (& inote))
15743         {
15744           res = 0;
15745           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15746                   inote.namesz, inote.descsz);
15747         }
15748     }
15749
15750   free (pnotes);
15751
15752   return res;
15753 }
15754
15755 static int
15756 process_note_sections (FILE * file)
15757 {
15758   Elf_Internal_Shdr * section;
15759   unsigned long i;
15760   int n = 0;
15761   int res = 1;
15762
15763   for (i = 0, section = section_headers;
15764        i < elf_header.e_shnum && section != NULL;
15765        i++, section++)
15766     {
15767       if (section->sh_type == SHT_NOTE)
15768         {
15769           res &= process_corefile_note_segment (file,
15770                                                 (bfd_vma) section->sh_offset,
15771                                                 (bfd_vma) section->sh_size);
15772           n++;
15773         }
15774
15775       if ((   elf_header.e_machine == EM_V800
15776            || elf_header.e_machine == EM_V850
15777            || elf_header.e_machine == EM_CYGNUS_V850)
15778           && section->sh_type == SHT_RENESAS_INFO)
15779         {
15780           res &= process_v850_notes (file,
15781                                      (bfd_vma) section->sh_offset,
15782                                      (bfd_vma) section->sh_size);
15783           n++;
15784         }
15785     }
15786
15787   if (n == 0)
15788     /* Try processing NOTE segments instead.  */
15789     return process_corefile_note_segments (file);
15790
15791   return res;
15792 }
15793
15794 static int
15795 process_notes (FILE * file)
15796 {
15797   /* If we have not been asked to display the notes then do nothing.  */
15798   if (! do_notes)
15799     return 1;
15800
15801   if (elf_header.e_type != ET_CORE)
15802     return process_note_sections (file);
15803
15804   /* No program headers means no NOTE segment.  */
15805   if (elf_header.e_phnum > 0)
15806     return process_corefile_note_segments (file);
15807
15808   printf (_("No note segments present in the core file.\n"));
15809   return 1;
15810 }
15811
15812 static int
15813 process_arch_specific (FILE * file)
15814 {
15815   if (! do_arch)
15816     return 1;
15817
15818   switch (elf_header.e_machine)
15819     {
15820     case EM_ARM:
15821       return process_arm_specific (file);
15822     case EM_MIPS:
15823     case EM_MIPS_RS3_LE:
15824       return process_mips_specific (file);
15825       break;
15826     case EM_NDS32:
15827       return process_nds32_specific (file);
15828       break;
15829     case EM_PPC:
15830       return process_power_specific (file);
15831       break;
15832     case EM_S390:
15833     case EM_S390_OLD:
15834       return process_s390_specific (file);
15835       break;
15836     case EM_SPARC:
15837     case EM_SPARC32PLUS:
15838     case EM_SPARCV9:
15839       return process_sparc_specific (file);
15840       break;
15841     case EM_TI_C6000:
15842       return process_tic6x_specific (file);
15843       break;
15844     case EM_MSP430:
15845       return process_msp430x_specific (file);
15846     default:
15847       break;
15848     }
15849   return 1;
15850 }
15851
15852 static int
15853 get_file_header (FILE * file)
15854 {
15855   /* Read in the identity array.  */
15856   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15857     return 0;
15858
15859   /* Determine how to read the rest of the header.  */
15860   switch (elf_header.e_ident[EI_DATA])
15861     {
15862     default: /* fall through */
15863     case ELFDATANONE: /* fall through */
15864     case ELFDATA2LSB:
15865       byte_get = byte_get_little_endian;
15866       byte_put = byte_put_little_endian;
15867       break;
15868     case ELFDATA2MSB:
15869       byte_get = byte_get_big_endian;
15870       byte_put = byte_put_big_endian;
15871       break;
15872     }
15873
15874   /* For now we only support 32 bit and 64 bit ELF files.  */
15875   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15876
15877   /* Read in the rest of the header.  */
15878   if (is_32bit_elf)
15879     {
15880       Elf32_External_Ehdr ehdr32;
15881
15882       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15883         return 0;
15884
15885       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15886       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15887       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15888       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15889       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15890       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15891       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15892       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15893       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15894       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15895       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15896       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15897       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15898     }
15899   else
15900     {
15901       Elf64_External_Ehdr ehdr64;
15902
15903       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15904          we will not be able to cope with the 64bit data found in
15905          64 ELF files.  Detect this now and abort before we start
15906          overwriting things.  */
15907       if (sizeof (bfd_vma) < 8)
15908         {
15909           error (_("This instance of readelf has been built without support for a\n\
15910 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15911           return 0;
15912         }
15913
15914       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15915         return 0;
15916
15917       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15918       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15919       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15920       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15921       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15922       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15923       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15924       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15925       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15926       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15927       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15928       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15929       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15930     }
15931
15932   if (elf_header.e_shoff)
15933     {
15934       /* There may be some extensions in the first section header.  Don't
15935          bomb if we can't read it.  */
15936       if (is_32bit_elf)
15937         get_32bit_section_headers (file, TRUE);
15938       else
15939         get_64bit_section_headers (file, TRUE);
15940     }
15941
15942   return 1;
15943 }
15944
15945 /* Process one ELF object file according to the command line options.
15946    This file may actually be stored in an archive.  The file is
15947    positioned at the start of the ELF object.  */
15948
15949 static int
15950 process_object (char * file_name, FILE * file)
15951 {
15952   unsigned int i;
15953
15954   if (! get_file_header (file))
15955     {
15956       error (_("%s: Failed to read file header\n"), file_name);
15957       return 1;
15958     }
15959
15960   /* Initialise per file variables.  */
15961   for (i = ARRAY_SIZE (version_info); i--;)
15962     version_info[i] = 0;
15963
15964   for (i = ARRAY_SIZE (dynamic_info); i--;)
15965     dynamic_info[i] = 0;
15966   dynamic_info_DT_GNU_HASH = 0;
15967
15968   /* Process the file.  */
15969   if (show_name)
15970     printf (_("\nFile: %s\n"), file_name);
15971
15972   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15973      Note we do this even if cmdline_dump_sects is empty because we
15974      must make sure that the dump_sets array is zeroed out before each
15975      object file is processed.  */
15976   if (num_dump_sects > num_cmdline_dump_sects)
15977     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15978
15979   if (num_cmdline_dump_sects > 0)
15980     {
15981       if (num_dump_sects == 0)
15982         /* A sneaky way of allocating the dump_sects array.  */
15983         request_dump_bynumber (num_cmdline_dump_sects, 0);
15984
15985       assert (num_dump_sects >= num_cmdline_dump_sects);
15986       memcpy (dump_sects, cmdline_dump_sects,
15987               num_cmdline_dump_sects * sizeof (* dump_sects));
15988     }
15989
15990   if (! process_file_header ())
15991     return 1;
15992
15993   if (! process_section_headers (file))
15994     {
15995       /* Without loaded section headers we cannot process lots of
15996          things.  */
15997       do_unwind = do_version = do_dump = do_arch = 0;
15998
15999       if (! do_using_dynamic)
16000         do_syms = do_dyn_syms = do_reloc = 0;
16001     }
16002
16003   if (! process_section_groups (file))
16004     {
16005       /* Without loaded section groups we cannot process unwind.  */
16006       do_unwind = 0;
16007     }
16008
16009   if (process_program_headers (file))
16010     process_dynamic_section (file);
16011
16012   process_relocs (file);
16013
16014   process_unwind (file);
16015
16016   process_symbol_table (file);
16017
16018   process_syminfo (file);
16019
16020   process_version_sections (file);
16021
16022   process_section_contents (file);
16023
16024   process_notes (file);
16025
16026   process_gnu_liblist (file);
16027
16028   process_arch_specific (file);
16029
16030   if (program_headers)
16031     {
16032       free (program_headers);
16033       program_headers = NULL;
16034     }
16035
16036   if (section_headers)
16037     {
16038       free (section_headers);
16039       section_headers = NULL;
16040     }
16041
16042   if (string_table)
16043     {
16044       free (string_table);
16045       string_table = NULL;
16046       string_table_length = 0;
16047     }
16048
16049   if (dynamic_strings)
16050     {
16051       free (dynamic_strings);
16052       dynamic_strings = NULL;
16053       dynamic_strings_length = 0;
16054     }
16055
16056   if (dynamic_symbols)
16057     {
16058       free (dynamic_symbols);
16059       dynamic_symbols = NULL;
16060       num_dynamic_syms = 0;
16061     }
16062
16063   if (dynamic_syminfo)
16064     {
16065       free (dynamic_syminfo);
16066       dynamic_syminfo = NULL;
16067     }
16068
16069   if (dynamic_section)
16070     {
16071       free (dynamic_section);
16072       dynamic_section = NULL;
16073     }
16074
16075   if (section_headers_groups)
16076     {
16077       free (section_headers_groups);
16078       section_headers_groups = NULL;
16079     }
16080
16081   if (section_groups)
16082     {
16083       struct group_list * g;
16084       struct group_list * next;
16085
16086       for (i = 0; i < group_count; i++)
16087         {
16088           for (g = section_groups [i].root; g != NULL; g = next)
16089             {
16090               next = g->next;
16091               free (g);
16092             }
16093         }
16094
16095       free (section_groups);
16096       section_groups = NULL;
16097     }
16098
16099   free_debug_memory ();
16100
16101   return 0;
16102 }
16103
16104 /* Process an ELF archive.
16105    On entry the file is positioned just after the ARMAG string.  */
16106
16107 static int
16108 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16109 {
16110   struct archive_info arch;
16111   struct archive_info nested_arch;
16112   size_t got;
16113   int ret;
16114
16115   show_name = 1;
16116
16117   /* The ARCH structure is used to hold information about this archive.  */
16118   arch.file_name = NULL;
16119   arch.file = NULL;
16120   arch.index_array = NULL;
16121   arch.sym_table = NULL;
16122   arch.longnames = NULL;
16123
16124   /* The NESTED_ARCH structure is used as a single-item cache of information
16125      about a nested archive (when members of a thin archive reside within
16126      another regular archive file).  */
16127   nested_arch.file_name = NULL;
16128   nested_arch.file = NULL;
16129   nested_arch.index_array = NULL;
16130   nested_arch.sym_table = NULL;
16131   nested_arch.longnames = NULL;
16132
16133   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16134     {
16135       ret = 1;
16136       goto out;
16137     }
16138
16139   if (do_archive_index)
16140     {
16141       if (arch.sym_table == NULL)
16142         error (_("%s: unable to dump the index as none was found\n"), file_name);
16143       else
16144         {
16145           unsigned long i, l;
16146           unsigned long current_pos;
16147
16148           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16149                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16150           current_pos = ftell (file);
16151
16152           for (i = l = 0; i < arch.index_num; i++)
16153             {
16154               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16155                 {
16156                   char * member_name;
16157
16158                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16159
16160                   if (member_name != NULL)
16161                     {
16162                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16163
16164                       if (qualified_name != NULL)
16165                         {
16166                           printf (_("Contents of binary %s at offset "), qualified_name);
16167                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16168                           putchar ('\n');
16169                           free (qualified_name);
16170                         }
16171                     }
16172                 }
16173
16174               if (l >= arch.sym_size)
16175                 {
16176                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16177                          file_name);
16178                   break;
16179                 }
16180               /* PR 17531: file: 0b6630b2.  */
16181               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16182               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16183             }
16184
16185           if (arch.uses_64bit_indicies)
16186             l = (l + 7) & ~ 7;
16187           else
16188             l += l & 1;
16189
16190           if (l < arch.sym_size)
16191             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16192                    file_name, arch.sym_size - l);
16193
16194           if (fseek (file, current_pos, SEEK_SET) != 0)
16195             {
16196               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16197               ret = 1;
16198               goto out;
16199             }
16200         }
16201
16202       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16203           && !do_segments && !do_header && !do_dump && !do_version
16204           && !do_histogram && !do_debugging && !do_arch && !do_notes
16205           && !do_section_groups && !do_dyn_syms)
16206         {
16207           ret = 0; /* Archive index only.  */
16208           goto out;
16209         }
16210     }
16211
16212   ret = 0;
16213
16214   while (1)
16215     {
16216       char * name;
16217       size_t namelen;
16218       char * qualified_name;
16219
16220       /* Read the next archive header.  */
16221       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16222         {
16223           error (_("%s: failed to seek to next archive header\n"), file_name);
16224           return 1;
16225         }
16226       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16227       if (got != sizeof arch.arhdr)
16228         {
16229           if (got == 0)
16230             break;
16231           error (_("%s: failed to read archive header\n"), file_name);
16232           ret = 1;
16233           break;
16234         }
16235       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16236         {
16237           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16238           ret = 1;
16239           break;
16240         }
16241
16242       arch.next_arhdr_offset += sizeof arch.arhdr;
16243
16244       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16245       if (archive_file_size & 01)
16246         ++archive_file_size;
16247
16248       name = get_archive_member_name (&arch, &nested_arch);
16249       if (name == NULL)
16250         {
16251           error (_("%s: bad archive file name\n"), file_name);
16252           ret = 1;
16253           break;
16254         }
16255       namelen = strlen (name);
16256
16257       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16258       if (qualified_name == NULL)
16259         {
16260           error (_("%s: bad archive file name\n"), file_name);
16261           ret = 1;
16262           break;
16263         }
16264
16265       if (is_thin_archive && arch.nested_member_origin == 0)
16266         {
16267           /* This is a proxy for an external member of a thin archive.  */
16268           FILE * member_file;
16269           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16270           if (member_file_name == NULL)
16271             {
16272               ret = 1;
16273               break;
16274             }
16275
16276           member_file = fopen (member_file_name, "rb");
16277           if (member_file == NULL)
16278             {
16279               error (_("Input file '%s' is not readable.\n"), member_file_name);
16280               free (member_file_name);
16281               ret = 1;
16282               break;
16283             }
16284
16285           archive_file_offset = arch.nested_member_origin;
16286
16287           ret |= process_object (qualified_name, member_file);
16288
16289           fclose (member_file);
16290           free (member_file_name);
16291         }
16292       else if (is_thin_archive)
16293         {
16294           /* PR 15140: Allow for corrupt thin archives.  */
16295           if (nested_arch.file == NULL)
16296             {
16297               error (_("%s: contains corrupt thin archive: %s\n"),
16298                      file_name, name);
16299               ret = 1;
16300               break;
16301             }
16302
16303           /* This is a proxy for a member of a nested archive.  */
16304           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16305
16306           /* The nested archive file will have been opened and setup by
16307              get_archive_member_name.  */
16308           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16309             {
16310               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16311               ret = 1;
16312               break;
16313             }
16314
16315           ret |= process_object (qualified_name, nested_arch.file);
16316         }
16317       else
16318         {
16319           archive_file_offset = arch.next_arhdr_offset;
16320           arch.next_arhdr_offset += archive_file_size;
16321
16322           ret |= process_object (qualified_name, file);
16323         }
16324
16325       if (dump_sects != NULL)
16326         {
16327           free (dump_sects);
16328           dump_sects = NULL;
16329           num_dump_sects = 0;
16330         }
16331
16332       free (qualified_name);
16333     }
16334
16335  out:
16336   if (nested_arch.file != NULL)
16337     fclose (nested_arch.file);
16338   release_archive (&nested_arch);
16339   release_archive (&arch);
16340
16341   return ret;
16342 }
16343
16344 static int
16345 process_file (char * file_name)
16346 {
16347   FILE * file;
16348   struct stat statbuf;
16349   char armag[SARMAG];
16350   int ret;
16351
16352   if (stat (file_name, &statbuf) < 0)
16353     {
16354       if (errno == ENOENT)
16355         error (_("'%s': No such file\n"), file_name);
16356       else
16357         error (_("Could not locate '%s'.  System error message: %s\n"),
16358                file_name, strerror (errno));
16359       return 1;
16360     }
16361
16362   if (! S_ISREG (statbuf.st_mode))
16363     {
16364       error (_("'%s' is not an ordinary file\n"), file_name);
16365       return 1;
16366     }
16367
16368   file = fopen (file_name, "rb");
16369   if (file == NULL)
16370     {
16371       error (_("Input file '%s' is not readable.\n"), file_name);
16372       return 1;
16373     }
16374
16375   if (fread (armag, SARMAG, 1, file) != 1)
16376     {
16377       error (_("%s: Failed to read file's magic number\n"), file_name);
16378       fclose (file);
16379       return 1;
16380     }
16381
16382   current_file_size = (bfd_size_type) statbuf.st_size;
16383
16384   if (memcmp (armag, ARMAG, SARMAG) == 0)
16385     ret = process_archive (file_name, file, FALSE);
16386   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16387     ret = process_archive (file_name, file, TRUE);
16388   else
16389     {
16390       if (do_archive_index)
16391         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16392                file_name);
16393
16394       rewind (file);
16395       archive_file_size = archive_file_offset = 0;
16396       ret = process_object (file_name, file);
16397     }
16398
16399   fclose (file);
16400
16401   current_file_size = 0;
16402   return ret;
16403 }
16404
16405 #ifdef SUPPORT_DISASSEMBLY
16406 /* Needed by the i386 disassembler.  For extra credit, someone could
16407    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16408    symbols.  */
16409
16410 void
16411 print_address (unsigned int addr, FILE * outfile)
16412 {
16413   fprintf (outfile,"0x%8.8x", addr);
16414 }
16415
16416 /* Needed by the i386 disassembler.  */
16417 void
16418 db_task_printsym (unsigned int addr)
16419 {
16420   print_address (addr, stderr);
16421 }
16422 #endif
16423
16424 int
16425 main (int argc, char ** argv)
16426 {
16427   int err;
16428
16429 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16430   setlocale (LC_MESSAGES, "");
16431 #endif
16432 #if defined (HAVE_SETLOCALE)
16433   setlocale (LC_CTYPE, "");
16434 #endif
16435   bindtextdomain (PACKAGE, LOCALEDIR);
16436   textdomain (PACKAGE);
16437
16438   expandargv (&argc, &argv);
16439
16440   parse_args (argc, argv);
16441
16442   if (num_dump_sects > 0)
16443     {
16444       /* Make a copy of the dump_sects array.  */
16445       cmdline_dump_sects = (dump_type *)
16446           malloc (num_dump_sects * sizeof (* dump_sects));
16447       if (cmdline_dump_sects == NULL)
16448         error (_("Out of memory allocating dump request table.\n"));
16449       else
16450         {
16451           memcpy (cmdline_dump_sects, dump_sects,
16452                   num_dump_sects * sizeof (* dump_sects));
16453           num_cmdline_dump_sects = num_dump_sects;
16454         }
16455     }
16456
16457   if (optind < (argc - 1))
16458     show_name = 1;
16459   else if (optind >= argc)
16460     {
16461       warn (_("Nothing to do.\n"));
16462       usage (stderr);
16463     }
16464
16465   err = 0;
16466   while (optind < argc)
16467     err |= process_file (argv[optind++]);
16468
16469   if (dump_sects != NULL)
16470     free (dump_sects);
16471   if (cmdline_dump_sects != NULL)
16472     free (cmdline_dump_sects);
16473
16474   return err;
16475 }