binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2016 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 typedef struct elf_section_list
 168 {
 169   Elf_Internal_Shdr * hdr;
 170   struct elf_section_list * next;
 171 } elf_section_list;
 172
 173 char * program_name = "readelf";
 174 static unsigned long archive_file_offset;
 175 static unsigned long archive_file_size;
 176 static bfd_size_type current_file_size;
 177 static unsigned long dynamic_addr;
 178 static bfd_size_type dynamic_size;
 179 static size_t dynamic_nent;
 180 static char * dynamic_strings;
 181 static unsigned long dynamic_strings_length;
 182 static char * string_table;
 183 static unsigned long string_table_length;
 184 static unsigned long num_dynamic_syms;
 185 static Elf_Internal_Sym * dynamic_symbols;
 186 static Elf_Internal_Syminfo * dynamic_syminfo;
 187 static unsigned long dynamic_syminfo_offset;
 188 static unsigned int dynamic_syminfo_nent;
 189 static char program_interpreter[PATH_MAX];
 190 static bfd_vma dynamic_info[DT_ENCODING];
 191 static bfd_vma dynamic_info_DT_GNU_HASH;
 192 static bfd_vma version_info[16];
 193 static Elf_Internal_Ehdr elf_header;
 194 static Elf_Internal_Shdr * section_headers;
 195 static Elf_Internal_Phdr * program_headers;
 196 static Elf_Internal_Dyn *  dynamic_section;
 197 static elf_section_list * symtab_shndx_list;
 198 static int show_name;
 199 static int do_dynamic;
 200 static int do_syms;
 201 static int do_dyn_syms;
 202 static int do_reloc;
 203 static int do_sections;
 204 static int do_section_groups;
 205 static int do_section_details;
 206 static int do_segments;
 207 static int do_unwind;
 208 static int do_using_dynamic;
 209 static int do_header;
 210 static int do_dump;
 211 static int do_version;
 212 static int do_histogram;
 213 static int do_debugging;
 214 static int do_arch;
 215 static int do_notes;
 216 static int do_archive_index;
 217 static int is_32bit_elf;
 218 static int decompress_dumps;
 219
 220 struct group_list
 221 {
 222   struct group_list * next;
 223   unsigned int section_index;
 224 };
 225
 226 struct group
 227 {
 228   struct group_list * root;
 229   unsigned int group_index;
 230 };
 231
 232 static size_t group_count;
 233 static struct group * section_groups;
 234 static struct group ** section_headers_groups;
 235
 236
 237 /* Flag bits indicating particular types of dump.  */
 238 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 239 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 240 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 241 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 242 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 243
 244 typedef unsigned char dump_type;
 245
 246 /* A linked list of the section names for which dumps were requested.  */
 247 struct dump_list_entry
 248 {
 249   char * name;
 250   dump_type type;
 251   struct dump_list_entry * next;
 252 };
 253 static struct dump_list_entry * dump_sects_byname;
 254
 255 /* A dynamic array of flags indicating for which sections a dump
 256    has been requested via command line switches.  */
 257 static dump_type *   cmdline_dump_sects = NULL;
 258 static unsigned int  num_cmdline_dump_sects = 0;
 259
 260 /* A dynamic array of flags indicating for which sections a dump of
 261    some kind has been requested.  It is reset on a per-object file
 262    basis and then initialised from the cmdline_dump_sects array,
 263    the results of interpreting the -w switch, and the
 264    dump_sects_byname list.  */
 265 static dump_type *   dump_sects = NULL;
 266 static unsigned int  num_dump_sects = 0;
 267
 268
 269 /* How to print a vma value.  */
 270 typedef enum print_mode
 271 {
 272   HEX,
 273   DEC,
 274   DEC_5,
 275   UNSIGNED,
 276   PREFIX_HEX,
 277   FULL_HEX,
 278   LONG_HEX
 279 }
 280 print_mode;
 281
 282 /* Versioned symbol info.  */
 283 enum versioned_symbol_info
 284 {
 285   symbol_undefined,
 286   symbol_hidden,
 287   symbol_public
 288 };
 289
 290 static const char *get_symbol_version_string
 291   (FILE *file, int is_dynsym, const char *strtab,
 292    unsigned long int strtab_size, unsigned int si,
 293    Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
 294    unsigned short *vna_other);
 295
 296 #define UNKNOWN -1
 297
 298 #define SECTION_NAME(X)                                         \
 299   ((X) == NULL ? _("<none>")                                    \
 300    : string_table == NULL ? _("<no-name>")                      \
 301    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 302   : string_table + (X)->sh_name))
 303
 304 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 305
 306 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 307   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 308    : get_64bit_elf_symbols (file, section, sym_count))
 309
 310 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 312    already been called and verified that the string exists.  */
 313 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 314
 315 #define REMOVE_ARCH_BITS(ADDR)                  \
 316   do                                            \
 317     {                                           \
 318       if (elf_header.e_machine == EM_ARM)       \
 319         (ADDR) &= ~1;                           \
 320     }                                           \
 321   while (0)
 322 \f
 323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 324    the offset of the current archive member, if we are examining an archive.
 325    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 326    using malloc and fill that.  In either case return the pointer to the start of
 327    the retrieved data or NULL if something went wrong.  If something does go wrong
 328    and REASON is not NULL then emit an error message using REASON as part of the
 329    context.  */
 330
 331 static void *
 332 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 333           bfd_size_type nmemb, const char * reason)
 334 {
 335   void * mvar;
 336   bfd_size_type amt = size * nmemb;
 337
 338   if (size == 0 || nmemb == 0)
 339     return NULL;
 340
 341   /* If the size_t type is smaller than the bfd_size_type, eg because
 342      you are building a 32-bit tool on a 64-bit host, then make sure
 343      that when the sizes are cast to (size_t) no information is lost.  */
 344   if (sizeof (size_t) < sizeof (bfd_size_type)
 345       && (   (bfd_size_type) ((size_t) size) != size
 346           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 347     {
 348       if (reason)
 349         error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 350                (unsigned long long) nmemb, (unsigned long long) size, reason);
 351       return NULL;
 352     }
 353
 354   /* Check for size overflow.  */
 355   if (amt < nmemb)
 356     {
 357       if (reason)
 358         error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 359                (unsigned long long) nmemb, (unsigned long long) size, reason);
 360       return NULL;
 361     }
 362
 363   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 364      attempting to allocate memory when the read is bound to fail.  */
 365   if (amt > current_file_size
 366       || offset + archive_file_offset + amt > current_file_size)
 367     {
 368       if (reason)
 369         error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
 370                (unsigned long long) amt, reason);
 371       return NULL;
 372     }
 373
 374   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 375     {
 376       if (reason)
 377         error (_("Unable to seek to 0x%lx for %s\n"),
 378                (unsigned long) archive_file_offset + offset, reason);
 379       return NULL;
 380     }
 381
 382   mvar = var;
 383   if (mvar == NULL)
 384     {
 385       /* Check for overflow.  */
 386       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 387         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 388         mvar = malloc ((size_t) amt + 1);
 389
 390       if (mvar == NULL)
 391         {
 392           if (reason)
 393             error (_("Out of memory allocating 0x%llx bytes for %s\n"),
 394                    (unsigned long long) amt, reason);
 395           return NULL;
 396         }
 397
 398       ((char *) mvar)[amt] = '\0';
 399     }
 400
 401   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 402     {
 403       if (reason)
 404         error (_("Unable to read in 0x%llx bytes of %s\n"),
 405                (unsigned long long) amt, reason);
 406       if (mvar != var)
 407         free (mvar);
 408       return NULL;
 409     }
 410
 411   return mvar;
 412 }
 413
 414 /* Print a VMA value.  */
 415
 416 static int
 417 print_vma (bfd_vma vma, print_mode mode)
 418 {
 419   int nc = 0;
 420
 421   switch (mode)
 422     {
 423     case FULL_HEX:
 424       nc = printf ("0x");
 425       /* Drop through.  */
 426
 427     case LONG_HEX:
 428 #ifdef BFD64
 429       if (is_32bit_elf)
 430         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 431 #endif
 432       printf_vma (vma);
 433       return nc + 16;
 434
 435     case DEC_5:
 436       if (vma <= 99999)
 437         return printf ("%5" BFD_VMA_FMT "d", vma);
 438       /* Drop through.  */
 439
 440     case PREFIX_HEX:
 441       nc = printf ("0x");
 442       /* Drop through.  */
 443
 444     case HEX:
 445       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 446
 447     case DEC:
 448       return printf ("%" BFD_VMA_FMT "d", vma);
 449
 450     case UNSIGNED:
 451       return printf ("%" BFD_VMA_FMT "u", vma);
 452     }
 453   return 0;
 454 }
 455
 456 /* Display a symbol on stdout.  Handles the display of control characters and
 457    multibye characters (assuming the host environment supports them).
 458
 459    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 460
 461    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 462    padding as necessary.
 463
 464    Returns the number of emitted characters.  */
 465
 466 static unsigned int
 467 print_symbol (int width, const char *symbol)
 468 {
 469   bfd_boolean extra_padding = FALSE;
 470   int num_printed = 0;
 471 #ifdef HAVE_MBSTATE_T
 472   mbstate_t state;
 473 #endif
 474   int width_remaining;
 475
 476   if (width < 0)
 477     {
 478       /* Keep the width positive.  This also helps.  */
 479       width = - width;
 480       extra_padding = TRUE;
 481     }
 482   assert (width != 0);
 483
 484   if (do_wide)
 485     /* Set the remaining width to a very large value.
 486        This simplifies the code below.  */
 487     width_remaining = INT_MAX;
 488   else
 489     width_remaining = width;
 490
 491 #ifdef HAVE_MBSTATE_T
 492   /* Initialise the multibyte conversion state.  */
 493   memset (& state, 0, sizeof (state));
 494 #endif
 495
 496   while (width_remaining)
 497     {
 498       size_t  n;
 499       const char c = *symbol++;
 500
 501       if (c == 0)
 502         break;
 503
 504       /* Do not print control characters directly as they can affect terminal
 505          settings.  Such characters usually appear in the names generated
 506          by the assembler for local labels.  */
 507       if (ISCNTRL (c))
 508         {
 509           if (width_remaining < 2)
 510             break;
 511
 512           printf ("^%c", c + 0x40);
 513           width_remaining -= 2;
 514           num_printed += 2;
 515         }
 516       else if (ISPRINT (c))
 517         {
 518           putchar (c);
 519           width_remaining --;
 520           num_printed ++;
 521         }
 522       else
 523         {
 524 #ifdef HAVE_MBSTATE_T
 525           wchar_t w;
 526 #endif
 527           /* Let printf do the hard work of displaying multibyte characters.  */
 528           printf ("%.1s", symbol - 1);
 529           width_remaining --;
 530           num_printed ++;
 531
 532 #ifdef HAVE_MBSTATE_T
 533           /* Try to find out how many bytes made up the character that was
 534              just printed.  Advance the symbol pointer past the bytes that
 535              were displayed.  */
 536           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 537 #else
 538           n = 1;
 539 #endif
 540           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 541             symbol += (n - 1);
 542         }
 543     }
 544
 545   if (extra_padding && num_printed < width)
 546     {
 547       /* Fill in the remaining spaces.  */
 548       printf ("%-*s", width - num_printed, " ");
 549       num_printed = width;
 550     }
 551
 552   return num_printed;
 553 }
 554
 555 /* Returns a pointer to a static buffer containing a  printable version of
 556    the given section's name.  Like print_symbol, except that it does not try
 557    to print multibyte characters, it just interprets them as hex values.  */
 558
 559 static const char *
 560 printable_section_name (const Elf_Internal_Shdr * sec)
 561 {
 562 #define MAX_PRINT_SEC_NAME_LEN 128
 563   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 564   const char * name = SECTION_NAME (sec);
 565   char *       buf = sec_name_buf;
 566   char         c;
 567   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 568
 569   while ((c = * name ++) != 0)
 570     {
 571       if (ISCNTRL (c))
 572         {
 573           if (remaining < 2)
 574             break;
 575
 576           * buf ++ = '^';
 577           * buf ++ = c + 0x40;
 578           remaining -= 2;
 579         }
 580       else if (ISPRINT (c))
 581         {
 582           * buf ++ = c;
 583           remaining -= 1;
 584         }
 585       else
 586         {
 587           static char hex[17] = "0123456789ABCDEF";
 588
 589           if (remaining < 4)
 590             break;
 591           * buf ++ = '<';
 592           * buf ++ = hex[(c & 0xf0) >> 4];
 593           * buf ++ = hex[c & 0x0f];
 594           * buf ++ = '>';
 595           remaining -= 4;
 596         }
 597
 598       if (remaining == 0)
 599         break;
 600     }
 601
 602   * buf = 0;
 603   return sec_name_buf;
 604 }
 605
 606 static const char *
 607 printable_section_name_from_index (unsigned long ndx)
 608 {
 609   if (ndx >= elf_header.e_shnum)
 610     return _("<corrupt>");
 611
 612   return printable_section_name (section_headers + ndx);
 613 }
 614
 615 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 616
 617 static Elf_Internal_Shdr *
 618 find_section (const char * name)
 619 {
 620   unsigned int i;
 621
 622   for (i = 0; i < elf_header.e_shnum; i++)
 623     if (streq (SECTION_NAME (section_headers + i), name))
 624       return section_headers + i;
 625
 626   return NULL;
 627 }
 628
 629 /* Return a pointer to a section containing ADDR, or NULL if no such
 630    section exists.  */
 631
 632 static Elf_Internal_Shdr *
 633 find_section_by_address (bfd_vma addr)
 634 {
 635   unsigned int i;
 636
 637   for (i = 0; i < elf_header.e_shnum; i++)
 638     {
 639       Elf_Internal_Shdr *sec = section_headers + i;
 640       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 641         return sec;
 642     }
 643
 644   return NULL;
 645 }
 646
 647 static Elf_Internal_Shdr *
 648 find_section_by_type (unsigned int type)
 649 {
 650   unsigned int i;
 651
 652   for (i = 0; i < elf_header.e_shnum; i++)
 653     {
 654       Elf_Internal_Shdr *sec = section_headers + i;
 655       if (sec->sh_type == type)
 656         return sec;
 657     }
 658
 659   return NULL;
 660 }
 661
 662 /* Return a pointer to section NAME, or NULL if no such section exists,
 663    restricted to the list of sections given in SET.  */
 664
 665 static Elf_Internal_Shdr *
 666 find_section_in_set (const char * name, unsigned int * set)
 667 {
 668   unsigned int i;
 669
 670   if (set != NULL)
 671     {
 672       while ((i = *set++) > 0)
 673         if (streq (SECTION_NAME (section_headers + i), name))
 674           return section_headers + i;
 675     }
 676
 677   return find_section (name);
 678 }
 679
 680 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 681    bytes read.  */
 682
 683 static inline unsigned long
 684 read_uleb128 (unsigned char *data,
 685               unsigned int *length_return,
 686               const unsigned char * const end)
 687 {
 688   return read_leb128 (data, length_return, FALSE, end);
 689 }
 690
 691 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 692    This OS has so many departures from the ELF standard that we test it at
 693    many places.  */
 694
 695 static inline int
 696 is_ia64_vms (void)
 697 {
 698   return elf_header.e_machine == EM_IA_64
 699     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 700 }
 701
 702 /* Guess the relocation size commonly used by the specific machines.  */
 703
 704 static int
 705 guess_is_rela (unsigned int e_machine)
 706 {
 707   switch (e_machine)
 708     {
 709       /* Targets that use REL relocations.  */
 710     case EM_386:
 711     case EM_IAMCU:
 712     case EM_960:
 713     case EM_ARM:
 714     case EM_D10V:
 715     case EM_CYGNUS_D10V:
 716     case EM_DLX:
 717     case EM_MIPS:
 718     case EM_MIPS_RS3_LE:
 719     case EM_CYGNUS_M32R:
 720     case EM_SCORE:
 721     case EM_XGATE:
 722       return FALSE;
 723
 724       /* Targets that use RELA relocations.  */
 725     case EM_68K:
 726     case EM_860:
 727     case EM_AARCH64:
 728     case EM_ADAPTEVA_EPIPHANY:
 729     case EM_ALPHA:
 730     case EM_ALTERA_NIOS2:
 731     case EM_ARC:
 732     case EM_ARC_COMPACT:
 733     case EM_ARC_COMPACT2:
 734     case EM_AVR:
 735     case EM_AVR_OLD:
 736     case EM_BLACKFIN:
 737     case EM_CR16:
 738     case EM_CRIS:
 739     case EM_CRX:
 740     case EM_D30V:
 741     case EM_CYGNUS_D30V:
 742     case EM_FR30:
 743     case EM_FT32:
 744     case EM_CYGNUS_FR30:
 745     case EM_CYGNUS_FRV:
 746     case EM_H8S:
 747     case EM_H8_300:
 748     case EM_H8_300H:
 749     case EM_IA_64:
 750     case EM_IP2K:
 751     case EM_IP2K_OLD:
 752     case EM_IQ2000:
 753     case EM_LATTICEMICO32:
 754     case EM_M32C_OLD:
 755     case EM_M32C:
 756     case EM_M32R:
 757     case EM_MCORE:
 758     case EM_CYGNUS_MEP:
 759     case EM_METAG:
 760     case EM_MMIX:
 761     case EM_MN10200:
 762     case EM_CYGNUS_MN10200:
 763     case EM_MN10300:
 764     case EM_CYGNUS_MN10300:
 765     case EM_MOXIE:
 766     case EM_MSP430:
 767     case EM_MSP430_OLD:
 768     case EM_MT:
 769     case EM_NDS32:
 770     case EM_NIOS32:
 771     case EM_OR1K:
 772     case EM_PPC64:
 773     case EM_PPC:
 774     case EM_RL78:
 775     case EM_RX:
 776     case EM_S390:
 777     case EM_S390_OLD:
 778     case EM_SH:
 779     case EM_SPARC:
 780     case EM_SPARC32PLUS:
 781     case EM_SPARCV9:
 782     case EM_SPU:
 783     case EM_TI_C6000:
 784     case EM_TILEGX:
 785     case EM_TILEPRO:
 786     case EM_V800:
 787     case EM_V850:
 788     case EM_CYGNUS_V850:
 789     case EM_VAX:
 790     case EM_VISIUM:
 791     case EM_X86_64:
 792     case EM_L1OM:
 793     case EM_K1OM:
 794     case EM_XSTORMY16:
 795     case EM_XTENSA:
 796     case EM_XTENSA_OLD:
 797     case EM_MICROBLAZE:
 798     case EM_MICROBLAZE_OLD:
 799       return TRUE;
 800
 801     case EM_68HC05:
 802     case EM_68HC08:
 803     case EM_68HC11:
 804     case EM_68HC16:
 805     case EM_FX66:
 806     case EM_ME16:
 807     case EM_MMA:
 808     case EM_NCPU:
 809     case EM_NDR1:
 810     case EM_PCP:
 811     case EM_ST100:
 812     case EM_ST19:
 813     case EM_ST7:
 814     case EM_ST9PLUS:
 815     case EM_STARCORE:
 816     case EM_SVX:
 817     case EM_TINYJ:
 818     default:
 819       warn (_("Don't know about relocations on this machine architecture\n"));
 820       return FALSE;
 821     }
 822 }
 823
 824 static int
 825 slurp_rela_relocs (FILE * file,
 826                    unsigned long rel_offset,
 827                    unsigned long rel_size,
 828                    Elf_Internal_Rela ** relasp,
 829                    unsigned long * nrelasp)
 830 {
 831   Elf_Internal_Rela * relas;
 832   size_t nrelas;
 833   unsigned int i;
 834
 835   if (is_32bit_elf)
 836     {
 837       Elf32_External_Rela * erelas;
 838
 839       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 840                                                  rel_size, _("32-bit relocation data"));
 841       if (!erelas)
 842         return 0;
 843
 844       nrelas = rel_size / sizeof (Elf32_External_Rela);
 845
 846       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 847                                              sizeof (Elf_Internal_Rela));
 848
 849       if (relas == NULL)
 850         {
 851           free (erelas);
 852           error (_("out of memory parsing relocs\n"));
 853           return 0;
 854         }
 855
 856       for (i = 0; i < nrelas; i++)
 857         {
 858           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 859           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 860           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 861         }
 862
 863       free (erelas);
 864     }
 865   else
 866     {
 867       Elf64_External_Rela * erelas;
 868
 869       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 870                                                  rel_size, _("64-bit relocation data"));
 871       if (!erelas)
 872         return 0;
 873
 874       nrelas = rel_size / sizeof (Elf64_External_Rela);
 875
 876       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 877                                              sizeof (Elf_Internal_Rela));
 878
 879       if (relas == NULL)
 880         {
 881           free (erelas);
 882           error (_("out of memory parsing relocs\n"));
 883           return 0;
 884         }
 885
 886       for (i = 0; i < nrelas; i++)
 887         {
 888           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 889           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 890           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 891
 892           /* The #ifdef BFD64 below is to prevent a compile time
 893              warning.  We know that if we do not have a 64 bit data
 894              type that we will never execute this code anyway.  */
 895 #ifdef BFD64
 896           if (elf_header.e_machine == EM_MIPS
 897               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 898             {
 899               /* In little-endian objects, r_info isn't really a
 900                  64-bit little-endian value: it has a 32-bit
 901                  little-endian symbol index followed by four
 902                  individual byte fields.  Reorder INFO
 903                  accordingly.  */
 904               bfd_vma inf = relas[i].r_info;
 905               inf = (((inf & 0xffffffff) << 32)
 906                       | ((inf >> 56) & 0xff)
 907                       | ((inf >> 40) & 0xff00)
 908                       | ((inf >> 24) & 0xff0000)
 909                       | ((inf >> 8) & 0xff000000));
 910               relas[i].r_info = inf;
 911             }
 912 #endif /* BFD64 */
 913         }
 914
 915       free (erelas);
 916     }
 917   *relasp = relas;
 918   *nrelasp = nrelas;
 919   return 1;
 920 }
 921
 922 static int
 923 slurp_rel_relocs (FILE * file,
 924                   unsigned long rel_offset,
 925                   unsigned long rel_size,
 926                   Elf_Internal_Rela ** relsp,
 927                   unsigned long * nrelsp)
 928 {
 929   Elf_Internal_Rela * rels;
 930   size_t nrels;
 931   unsigned int i;
 932
 933   if (is_32bit_elf)
 934     {
 935       Elf32_External_Rel * erels;
 936
 937       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 938                                                rel_size, _("32-bit relocation data"));
 939       if (!erels)
 940         return 0;
 941
 942       nrels = rel_size / sizeof (Elf32_External_Rel);
 943
 944       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 945
 946       if (rels == NULL)
 947         {
 948           free (erels);
 949           error (_("out of memory parsing relocs\n"));
 950           return 0;
 951         }
 952
 953       for (i = 0; i < nrels; i++)
 954         {
 955           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 956           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 957           rels[i].r_addend = 0;
 958         }
 959
 960       free (erels);
 961     }
 962   else
 963     {
 964       Elf64_External_Rel * erels;
 965
 966       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 967                                                rel_size, _("64-bit relocation data"));
 968       if (!erels)
 969         return 0;
 970
 971       nrels = rel_size / sizeof (Elf64_External_Rel);
 972
 973       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 974
 975       if (rels == NULL)
 976         {
 977           free (erels);
 978           error (_("out of memory parsing relocs\n"));
 979           return 0;
 980         }
 981
 982       for (i = 0; i < nrels; i++)
 983         {
 984           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 985           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 986           rels[i].r_addend = 0;
 987
 988           /* The #ifdef BFD64 below is to prevent a compile time
 989              warning.  We know that if we do not have a 64 bit data
 990              type that we will never execute this code anyway.  */
 991 #ifdef BFD64
 992           if (elf_header.e_machine == EM_MIPS
 993               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 994             {
 995               /* In little-endian objects, r_info isn't really a
 996                  64-bit little-endian value: it has a 32-bit
 997                  little-endian symbol index followed by four
 998                  individual byte fields.  Reorder INFO
 999                  accordingly.  */
1000               bfd_vma inf = rels[i].r_info;
1001               inf = (((inf & 0xffffffff) << 32)
1002                      | ((inf >> 56) & 0xff)
1003                      | ((inf >> 40) & 0xff00)
1004                      | ((inf >> 24) & 0xff0000)
1005                      | ((inf >> 8) & 0xff000000));
1006               rels[i].r_info = inf;
1007             }
1008 #endif /* BFD64 */
1009         }
1010
1011       free (erels);
1012     }
1013   *relsp = rels;
1014   *nrelsp = nrels;
1015   return 1;
1016 }
1017
1018 /* Returns the reloc type extracted from the reloc info field.  */
1019
1020 static unsigned int
1021 get_reloc_type (bfd_vma reloc_info)
1022 {
1023   if (is_32bit_elf)
1024     return ELF32_R_TYPE (reloc_info);
1025
1026   switch (elf_header.e_machine)
1027     {
1028     case EM_MIPS:
1029       /* Note: We assume that reloc_info has already been adjusted for us.  */
1030       return ELF64_MIPS_R_TYPE (reloc_info);
1031
1032     case EM_SPARCV9:
1033       return ELF64_R_TYPE_ID (reloc_info);
1034
1035     default:
1036       return ELF64_R_TYPE (reloc_info);
1037     }
1038 }
1039
1040 /* Return the symbol index extracted from the reloc info field.  */
1041
1042 static bfd_vma
1043 get_reloc_symindex (bfd_vma reloc_info)
1044 {
1045   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1046 }
1047
1048 static inline bfd_boolean
1049 uses_msp430x_relocs (void)
1050 {
1051   return
1052     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1053     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1054     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1055         /* TI compiler uses ELFOSABI_NONE.  */
1056         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1057 }
1058
1059 /* Display the contents of the relocation data found at the specified
1060    offset.  */
1061
1062 static void
1063 dump_relocations (FILE * file,
1064                   unsigned long rel_offset,
1065                   unsigned long rel_size,
1066                   Elf_Internal_Sym * symtab,
1067                   unsigned long nsyms,
1068                   char * strtab,
1069                   unsigned long strtablen,
1070                   int is_rela,
1071                   int is_dynsym)
1072 {
1073   unsigned int i;
1074   Elf_Internal_Rela * rels;
1075
1076   if (is_rela == UNKNOWN)
1077     is_rela = guess_is_rela (elf_header.e_machine);
1078
1079   if (is_rela)
1080     {
1081       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1082         return;
1083     }
1084   else
1085     {
1086       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1087         return;
1088     }
1089
1090   if (is_32bit_elf)
1091     {
1092       if (is_rela)
1093         {
1094           if (do_wide)
1095             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1096           else
1097             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1098         }
1099       else
1100         {
1101           if (do_wide)
1102             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1103           else
1104             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1105         }
1106     }
1107   else
1108     {
1109       if (is_rela)
1110         {
1111           if (do_wide)
1112             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1113           else
1114             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1115         }
1116       else
1117         {
1118           if (do_wide)
1119             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1120           else
1121             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1122         }
1123     }
1124
1125   for (i = 0; i < rel_size; i++)
1126     {
1127       const char * rtype;
1128       bfd_vma offset;
1129       bfd_vma inf;
1130       bfd_vma symtab_index;
1131       bfd_vma type;
1132
1133       offset = rels[i].r_offset;
1134       inf    = rels[i].r_info;
1135
1136       type = get_reloc_type (inf);
1137       symtab_index = get_reloc_symindex  (inf);
1138
1139       if (is_32bit_elf)
1140         {
1141           printf ("%8.8lx  %8.8lx ",
1142                   (unsigned long) offset & 0xffffffff,
1143                   (unsigned long) inf & 0xffffffff);
1144         }
1145       else
1146         {
1147 #if BFD_HOST_64BIT_LONG
1148           printf (do_wide
1149                   ? "%16.16lx  %16.16lx "
1150                   : "%12.12lx  %12.12lx ",
1151                   offset, inf);
1152 #elif BFD_HOST_64BIT_LONG_LONG
1153 #ifndef __MSVCRT__
1154           printf (do_wide
1155                   ? "%16.16llx  %16.16llx "
1156                   : "%12.12llx  %12.12llx ",
1157                   offset, inf);
1158 #else
1159           printf (do_wide
1160                   ? "%16.16I64x  %16.16I64x "
1161                   : "%12.12I64x  %12.12I64x ",
1162                   offset, inf);
1163 #endif
1164 #else
1165           printf (do_wide
1166                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1167                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1168                   _bfd_int64_high (offset),
1169                   _bfd_int64_low (offset),
1170                   _bfd_int64_high (inf),
1171                   _bfd_int64_low (inf));
1172 #endif
1173         }
1174
1175       switch (elf_header.e_machine)
1176         {
1177         default:
1178           rtype = NULL;
1179           break;
1180
1181         case EM_AARCH64:
1182           rtype = elf_aarch64_reloc_type (type);
1183           break;
1184
1185         case EM_M32R:
1186         case EM_CYGNUS_M32R:
1187           rtype = elf_m32r_reloc_type (type);
1188           break;
1189
1190         case EM_386:
1191         case EM_IAMCU:
1192           rtype = elf_i386_reloc_type (type);
1193           break;
1194
1195         case EM_68HC11:
1196         case EM_68HC12:
1197           rtype = elf_m68hc11_reloc_type (type);
1198           break;
1199
1200         case EM_68K:
1201           rtype = elf_m68k_reloc_type (type);
1202           break;
1203
1204         case EM_960:
1205           rtype = elf_i960_reloc_type (type);
1206           break;
1207
1208         case EM_AVR:
1209         case EM_AVR_OLD:
1210           rtype = elf_avr_reloc_type (type);
1211           break;
1212
1213         case EM_OLD_SPARCV9:
1214         case EM_SPARC32PLUS:
1215         case EM_SPARCV9:
1216         case EM_SPARC:
1217           rtype = elf_sparc_reloc_type (type);
1218           break;
1219
1220         case EM_SPU:
1221           rtype = elf_spu_reloc_type (type);
1222           break;
1223
1224         case EM_V800:
1225           rtype = v800_reloc_type (type);
1226           break;
1227         case EM_V850:
1228         case EM_CYGNUS_V850:
1229           rtype = v850_reloc_type (type);
1230           break;
1231
1232         case EM_D10V:
1233         case EM_CYGNUS_D10V:
1234           rtype = elf_d10v_reloc_type (type);
1235           break;
1236
1237         case EM_D30V:
1238         case EM_CYGNUS_D30V:
1239           rtype = elf_d30v_reloc_type (type);
1240           break;
1241
1242         case EM_DLX:
1243           rtype = elf_dlx_reloc_type (type);
1244           break;
1245
1246         case EM_SH:
1247           rtype = elf_sh_reloc_type (type);
1248           break;
1249
1250         case EM_MN10300:
1251         case EM_CYGNUS_MN10300:
1252           rtype = elf_mn10300_reloc_type (type);
1253           break;
1254
1255         case EM_MN10200:
1256         case EM_CYGNUS_MN10200:
1257           rtype = elf_mn10200_reloc_type (type);
1258           break;
1259
1260         case EM_FR30:
1261         case EM_CYGNUS_FR30:
1262           rtype = elf_fr30_reloc_type (type);
1263           break;
1264
1265         case EM_CYGNUS_FRV:
1266           rtype = elf_frv_reloc_type (type);
1267           break;
1268
1269         case EM_FT32:
1270           rtype = elf_ft32_reloc_type (type);
1271           break;
1272
1273         case EM_MCORE:
1274           rtype = elf_mcore_reloc_type (type);
1275           break;
1276
1277         case EM_MMIX:
1278           rtype = elf_mmix_reloc_type (type);
1279           break;
1280
1281         case EM_MOXIE:
1282           rtype = elf_moxie_reloc_type (type);
1283           break;
1284
1285         case EM_MSP430:
1286           if (uses_msp430x_relocs ())
1287             {
1288               rtype = elf_msp430x_reloc_type (type);
1289               break;
1290             }
1291         case EM_MSP430_OLD:
1292           rtype = elf_msp430_reloc_type (type);
1293           break;
1294
1295         case EM_NDS32:
1296           rtype = elf_nds32_reloc_type (type);
1297           break;
1298
1299         case EM_PPC:
1300           rtype = elf_ppc_reloc_type (type);
1301           break;
1302
1303         case EM_PPC64:
1304           rtype = elf_ppc64_reloc_type (type);
1305           break;
1306
1307         case EM_MIPS:
1308         case EM_MIPS_RS3_LE:
1309           rtype = elf_mips_reloc_type (type);
1310           break;
1311
1312         case EM_ALPHA:
1313           rtype = elf_alpha_reloc_type (type);
1314           break;
1315
1316         case EM_ARM:
1317           rtype = elf_arm_reloc_type (type);
1318           break;
1319
1320         case EM_ARC:
1321         case EM_ARC_COMPACT:
1322         case EM_ARC_COMPACT2:
1323           rtype = elf_arc_reloc_type (type);
1324           break;
1325
1326         case EM_PARISC:
1327           rtype = elf_hppa_reloc_type (type);
1328           break;
1329
1330         case EM_H8_300:
1331         case EM_H8_300H:
1332         case EM_H8S:
1333           rtype = elf_h8_reloc_type (type);
1334           break;
1335
1336         case EM_OR1K:
1337           rtype = elf_or1k_reloc_type (type);
1338           break;
1339
1340         case EM_PJ:
1341         case EM_PJ_OLD:
1342           rtype = elf_pj_reloc_type (type);
1343           break;
1344         case EM_IA_64:
1345           rtype = elf_ia64_reloc_type (type);
1346           break;
1347
1348         case EM_CRIS:
1349           rtype = elf_cris_reloc_type (type);
1350           break;
1351
1352         case EM_860:
1353           rtype = elf_i860_reloc_type (type);
1354           break;
1355
1356         case EM_X86_64:
1357         case EM_L1OM:
1358         case EM_K1OM:
1359           rtype = elf_x86_64_reloc_type (type);
1360           break;
1361
1362         case EM_S370:
1363           rtype = i370_reloc_type (type);
1364           break;
1365
1366         case EM_S390_OLD:
1367         case EM_S390:
1368           rtype = elf_s390_reloc_type (type);
1369           break;
1370
1371         case EM_SCORE:
1372           rtype = elf_score_reloc_type (type);
1373           break;
1374
1375         case EM_XSTORMY16:
1376           rtype = elf_xstormy16_reloc_type (type);
1377           break;
1378
1379         case EM_CRX:
1380           rtype = elf_crx_reloc_type (type);
1381           break;
1382
1383         case EM_VAX:
1384           rtype = elf_vax_reloc_type (type);
1385           break;
1386
1387         case EM_VISIUM:
1388           rtype = elf_visium_reloc_type (type);
1389           break;
1390
1391         case EM_ADAPTEVA_EPIPHANY:
1392           rtype = elf_epiphany_reloc_type (type);
1393           break;
1394
1395         case EM_IP2K:
1396         case EM_IP2K_OLD:
1397           rtype = elf_ip2k_reloc_type (type);
1398           break;
1399
1400         case EM_IQ2000:
1401           rtype = elf_iq2000_reloc_type (type);
1402           break;
1403
1404         case EM_XTENSA_OLD:
1405         case EM_XTENSA:
1406           rtype = elf_xtensa_reloc_type (type);
1407           break;
1408
1409         case EM_LATTICEMICO32:
1410           rtype = elf_lm32_reloc_type (type);
1411           break;
1412
1413         case EM_M32C_OLD:
1414         case EM_M32C:
1415           rtype = elf_m32c_reloc_type (type);
1416           break;
1417
1418         case EM_MT:
1419           rtype = elf_mt_reloc_type (type);
1420           break;
1421
1422         case EM_BLACKFIN:
1423           rtype = elf_bfin_reloc_type (type);
1424           break;
1425
1426         case EM_CYGNUS_MEP:
1427           rtype = elf_mep_reloc_type (type);
1428           break;
1429
1430         case EM_CR16:
1431           rtype = elf_cr16_reloc_type (type);
1432           break;
1433
1434         case EM_MICROBLAZE:
1435         case EM_MICROBLAZE_OLD:
1436           rtype = elf_microblaze_reloc_type (type);
1437           break;
1438
1439         case EM_RL78:
1440           rtype = elf_rl78_reloc_type (type);
1441           break;
1442
1443         case EM_RX:
1444           rtype = elf_rx_reloc_type (type);
1445           break;
1446
1447         case EM_METAG:
1448           rtype = elf_metag_reloc_type (type);
1449           break;
1450
1451         case EM_XC16X:
1452         case EM_C166:
1453           rtype = elf_xc16x_reloc_type (type);
1454           break;
1455
1456         case EM_TI_C6000:
1457           rtype = elf_tic6x_reloc_type (type);
1458           break;
1459
1460         case EM_TILEGX:
1461           rtype = elf_tilegx_reloc_type (type);
1462           break;
1463
1464         case EM_TILEPRO:
1465           rtype = elf_tilepro_reloc_type (type);
1466           break;
1467
1468         case EM_XGATE:
1469           rtype = elf_xgate_reloc_type (type);
1470           break;
1471
1472         case EM_ALTERA_NIOS2:
1473           rtype = elf_nios2_reloc_type (type);
1474           break;
1475         }
1476
1477       if (rtype == NULL)
1478         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1479       else
1480         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1481
1482       if (elf_header.e_machine == EM_ALPHA
1483           && rtype != NULL
1484           && streq (rtype, "R_ALPHA_LITUSE")
1485           && is_rela)
1486         {
1487           switch (rels[i].r_addend)
1488             {
1489             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1490             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1491             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1492             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1493             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1494             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1495             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1496             default: rtype = NULL;
1497             }
1498           if (rtype)
1499             printf (" (%s)", rtype);
1500           else
1501             {
1502               putchar (' ');
1503               printf (_("<unknown addend: %lx>"),
1504                       (unsigned long) rels[i].r_addend);
1505             }
1506         }
1507       else if (symtab_index)
1508         {
1509           if (symtab == NULL || symtab_index >= nsyms)
1510             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1511           else
1512             {
1513               Elf_Internal_Sym * psym;
1514               const char * version_string;
1515               enum versioned_symbol_info sym_info;
1516               unsigned short vna_other;
1517
1518               psym = symtab + symtab_index;
1519
1520               version_string
1521                 = get_symbol_version_string (file, is_dynsym,
1522                                              strtab, strtablen,
1523                                              symtab_index,
1524                                              psym,
1525                                              &sym_info,
1526                                              &vna_other);
1527
1528               printf (" ");
1529
1530               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1531                 {
1532                   const char * name;
1533                   unsigned int len;
1534                   unsigned int width = is_32bit_elf ? 8 : 14;
1535
1536                   /* Relocations against GNU_IFUNC symbols do not use the value
1537                      of the symbol as the address to relocate against.  Instead
1538                      they invoke the function named by the symbol and use its
1539                      result as the address for relocation.
1540
1541                      To indicate this to the user, do not display the value of
1542                      the symbol in the "Symbols's Value" field.  Instead show
1543                      its name followed by () as a hint that the symbol is
1544                      invoked.  */
1545
1546                   if (strtab == NULL
1547                       || psym->st_name == 0
1548                       || psym->st_name >= strtablen)
1549                     name = "??";
1550                   else
1551                     name = strtab + psym->st_name;
1552
1553                   len = print_symbol (width, name);
1554                   if (version_string)
1555                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1556                             version_string);
1557                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1558                 }
1559               else
1560                 {
1561                   print_vma (psym->st_value, LONG_HEX);
1562
1563                   printf (is_32bit_elf ? "   " : " ");
1564                 }
1565
1566               if (psym->st_name == 0)
1567                 {
1568                   const char * sec_name = "<null>";
1569                   char name_buf[40];
1570
1571                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1572                     {
1573                       if (psym->st_shndx < elf_header.e_shnum)
1574                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1575                       else if (psym->st_shndx == SHN_ABS)
1576                         sec_name = "ABS";
1577                       else if (psym->st_shndx == SHN_COMMON)
1578                         sec_name = "COMMON";
1579                       else if ((elf_header.e_machine == EM_MIPS
1580                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1581                                || (elf_header.e_machine == EM_TI_C6000
1582                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1583                         sec_name = "SCOMMON";
1584                       else if (elf_header.e_machine == EM_MIPS
1585                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1586                         sec_name = "SUNDEF";
1587                       else if ((elf_header.e_machine == EM_X86_64
1588                                 || elf_header.e_machine == EM_L1OM
1589                                 || elf_header.e_machine == EM_K1OM)
1590                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1591                         sec_name = "LARGE_COMMON";
1592                       else if (elf_header.e_machine == EM_IA_64
1593                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1594                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1595                         sec_name = "ANSI_COM";
1596                       else if (is_ia64_vms ()
1597                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1598                         sec_name = "VMS_SYMVEC";
1599                       else
1600                         {
1601                           sprintf (name_buf, "<section 0x%x>",
1602                                    (unsigned int) psym->st_shndx);
1603                           sec_name = name_buf;
1604                         }
1605                     }
1606                   print_symbol (22, sec_name);
1607                 }
1608               else if (strtab == NULL)
1609                 printf (_("<string table index: %3ld>"), psym->st_name);
1610               else if (psym->st_name >= strtablen)
1611                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1612               else
1613                 {
1614                   print_symbol (22, strtab + psym->st_name);
1615                   if (version_string)
1616                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1617                             version_string);
1618                 }
1619
1620               if (is_rela)
1621                 {
1622                   bfd_vma off = rels[i].r_addend;
1623
1624                   if ((bfd_signed_vma) off < 0)
1625                     printf (" - %" BFD_VMA_FMT "x", - off);
1626                   else
1627                     printf (" + %" BFD_VMA_FMT "x", off);
1628                 }
1629             }
1630         }
1631       else if (is_rela)
1632         {
1633           bfd_vma off = rels[i].r_addend;
1634
1635           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1636           if ((bfd_signed_vma) off < 0)
1637             printf ("-%" BFD_VMA_FMT "x", - off);
1638           else
1639             printf ("%" BFD_VMA_FMT "x", off);
1640         }
1641
1642       if (elf_header.e_machine == EM_SPARCV9
1643           && rtype != NULL
1644           && streq (rtype, "R_SPARC_OLO10"))
1645         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1646
1647       putchar ('\n');
1648
1649 #ifdef BFD64
1650       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1651         {
1652           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1653           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1654           const char * rtype2 = elf_mips_reloc_type (type2);
1655           const char * rtype3 = elf_mips_reloc_type (type3);
1656
1657           printf ("                    Type2: ");
1658
1659           if (rtype2 == NULL)
1660             printf (_("unrecognized: %-7lx"),
1661                     (unsigned long) type2 & 0xffffffff);
1662           else
1663             printf ("%-17.17s", rtype2);
1664
1665           printf ("\n                    Type3: ");
1666
1667           if (rtype3 == NULL)
1668             printf (_("unrecognized: %-7lx"),
1669                     (unsigned long) type3 & 0xffffffff);
1670           else
1671             printf ("%-17.17s", rtype3);
1672
1673           putchar ('\n');
1674         }
1675 #endif /* BFD64 */
1676     }
1677
1678   free (rels);
1679 }
1680
1681 static const char *
1682 get_mips_dynamic_type (unsigned long type)
1683 {
1684   switch (type)
1685     {
1686     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1687     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1688     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1689     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1690     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1691     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1692     case DT_MIPS_MSYM: return "MIPS_MSYM";
1693     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1694     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1695     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1696     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1697     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1698     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1699     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1700     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1701     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1702     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1703     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1704     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1705     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1706     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1707     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1708     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1709     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1710     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1711     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1712     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1713     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1714     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1715     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1716     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1717     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1718     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1719     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1720     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1721     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1722     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1723     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1724     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1725     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1727     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1728     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1729     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1730     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1731     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1732     default:
1733       return NULL;
1734     }
1735 }
1736
1737 static const char *
1738 get_sparc64_dynamic_type (unsigned long type)
1739 {
1740   switch (type)
1741     {
1742     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1743     default:
1744       return NULL;
1745     }
1746 }
1747
1748 static const char *
1749 get_ppc_dynamic_type (unsigned long type)
1750 {
1751   switch (type)
1752     {
1753     case DT_PPC_GOT:    return "PPC_GOT";
1754     case DT_PPC_OPT:    return "PPC_OPT";
1755     default:
1756       return NULL;
1757     }
1758 }
1759
1760 static const char *
1761 get_ppc64_dynamic_type (unsigned long type)
1762 {
1763   switch (type)
1764     {
1765     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1766     case DT_PPC64_OPD:    return "PPC64_OPD";
1767     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1768     case DT_PPC64_OPT:    return "PPC64_OPT";
1769     default:
1770       return NULL;
1771     }
1772 }
1773
1774 static const char *
1775 get_parisc_dynamic_type (unsigned long type)
1776 {
1777   switch (type)
1778     {
1779     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1780     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1781     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1782     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1783     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1784     case DT_HP_PREINIT:         return "HP_PREINIT";
1785     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1786     case DT_HP_NEEDED:          return "HP_NEEDED";
1787     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1788     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1789     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1790     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1791     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1792     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1793     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1794     case DT_HP_FILTERED:        return "HP_FILTERED";
1795     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1796     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1797     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1798     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1799     case DT_PLT:                return "PLT";
1800     case DT_PLT_SIZE:           return "PLT_SIZE";
1801     case DT_DLT:                return "DLT";
1802     case DT_DLT_SIZE:           return "DLT_SIZE";
1803     default:
1804       return NULL;
1805     }
1806 }
1807
1808 static const char *
1809 get_ia64_dynamic_type (unsigned long type)
1810 {
1811   switch (type)
1812     {
1813     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1814     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1815     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1816     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1817     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1818     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1819     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1820     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1821     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1822     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1823     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1824     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1825     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1826     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1827     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1828     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1829     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1830     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1831     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1832     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1833     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1834     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1835     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1836     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1837     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1838     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1839     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1840     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1841     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1842     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1843     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1844     default:
1845       return NULL;
1846     }
1847 }
1848
1849 static const char *
1850 get_alpha_dynamic_type (unsigned long type)
1851 {
1852   switch (type)
1853     {
1854     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1855     default:
1856       return NULL;
1857     }
1858 }
1859
1860 static const char *
1861 get_score_dynamic_type (unsigned long type)
1862 {
1863   switch (type)
1864     {
1865     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1866     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1867     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1868     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1869     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1870     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1871     default:
1872       return NULL;
1873     }
1874 }
1875
1876 static const char *
1877 get_tic6x_dynamic_type (unsigned long type)
1878 {
1879   switch (type)
1880     {
1881     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1882     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1883     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1884     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1885     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1886     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1887     default:
1888       return NULL;
1889     }
1890 }
1891
1892 static const char *
1893 get_nios2_dynamic_type (unsigned long type)
1894 {
1895   switch (type)
1896     {
1897     case DT_NIOS2_GP: return "NIOS2_GP";
1898     default:
1899       return NULL;
1900     }
1901 }
1902
1903 static const char *
1904 get_dynamic_type (unsigned long type)
1905 {
1906   static char buff[64];
1907
1908   switch (type)
1909     {
1910     case DT_NULL:       return "NULL";
1911     case DT_NEEDED:     return "NEEDED";
1912     case DT_PLTRELSZ:   return "PLTRELSZ";
1913     case DT_PLTGOT:     return "PLTGOT";
1914     case DT_HASH:       return "HASH";
1915     case DT_STRTAB:     return "STRTAB";
1916     case DT_SYMTAB:     return "SYMTAB";
1917     case DT_RELA:       return "RELA";
1918     case DT_RELASZ:     return "RELASZ";
1919     case DT_RELAENT:    return "RELAENT";
1920     case DT_STRSZ:      return "STRSZ";
1921     case DT_SYMENT:     return "SYMENT";
1922     case DT_INIT:       return "INIT";
1923     case DT_FINI:       return "FINI";
1924     case DT_SONAME:     return "SONAME";
1925     case DT_RPATH:      return "RPATH";
1926     case DT_SYMBOLIC:   return "SYMBOLIC";
1927     case DT_REL:        return "REL";
1928     case DT_RELSZ:      return "RELSZ";
1929     case DT_RELENT:     return "RELENT";
1930     case DT_PLTREL:     return "PLTREL";
1931     case DT_DEBUG:      return "DEBUG";
1932     case DT_TEXTREL:    return "TEXTREL";
1933     case DT_JMPREL:     return "JMPREL";
1934     case DT_BIND_NOW:   return "BIND_NOW";
1935     case DT_INIT_ARRAY: return "INIT_ARRAY";
1936     case DT_FINI_ARRAY: return "FINI_ARRAY";
1937     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1938     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1939     case DT_RUNPATH:    return "RUNPATH";
1940     case DT_FLAGS:      return "FLAGS";
1941
1942     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1943     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1944
1945     case DT_CHECKSUM:   return "CHECKSUM";
1946     case DT_PLTPADSZ:   return "PLTPADSZ";
1947     case DT_MOVEENT:    return "MOVEENT";
1948     case DT_MOVESZ:     return "MOVESZ";
1949     case DT_FEATURE:    return "FEATURE";
1950     case DT_POSFLAG_1:  return "POSFLAG_1";
1951     case DT_SYMINSZ:    return "SYMINSZ";
1952     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1953
1954     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1955     case DT_CONFIG:     return "CONFIG";
1956     case DT_DEPAUDIT:   return "DEPAUDIT";
1957     case DT_AUDIT:      return "AUDIT";
1958     case DT_PLTPAD:     return "PLTPAD";
1959     case DT_MOVETAB:    return "MOVETAB";
1960     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1961
1962     case DT_VERSYM:     return "VERSYM";
1963
1964     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1965     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1966     case DT_RELACOUNT:  return "RELACOUNT";
1967     case DT_RELCOUNT:   return "RELCOUNT";
1968     case DT_FLAGS_1:    return "FLAGS_1";
1969     case DT_VERDEF:     return "VERDEF";
1970     case DT_VERDEFNUM:  return "VERDEFNUM";
1971     case DT_VERNEED:    return "VERNEED";
1972     case DT_VERNEEDNUM: return "VERNEEDNUM";
1973
1974     case DT_AUXILIARY:  return "AUXILIARY";
1975     case DT_USED:       return "USED";
1976     case DT_FILTER:     return "FILTER";
1977
1978     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1979     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1980     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1981     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1982     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1983     case DT_GNU_HASH:   return "GNU_HASH";
1984
1985     default:
1986       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1987         {
1988           const char * result;
1989
1990           switch (elf_header.e_machine)
1991             {
1992             case EM_MIPS:
1993             case EM_MIPS_RS3_LE:
1994               result = get_mips_dynamic_type (type);
1995               break;
1996             case EM_SPARCV9:
1997               result = get_sparc64_dynamic_type (type);
1998               break;
1999             case EM_PPC:
2000               result = get_ppc_dynamic_type (type);
2001               break;
2002             case EM_PPC64:
2003               result = get_ppc64_dynamic_type (type);
2004               break;
2005             case EM_IA_64:
2006               result = get_ia64_dynamic_type (type);
2007               break;
2008             case EM_ALPHA:
2009               result = get_alpha_dynamic_type (type);
2010               break;
2011             case EM_SCORE:
2012               result = get_score_dynamic_type (type);
2013               break;
2014             case EM_TI_C6000:
2015               result = get_tic6x_dynamic_type (type);
2016               break;
2017             case EM_ALTERA_NIOS2:
2018               result = get_nios2_dynamic_type (type);
2019               break;
2020             default:
2021               result = NULL;
2022               break;
2023             }
2024
2025           if (result != NULL)
2026             return result;
2027
2028           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2029         }
2030       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2031                || (elf_header.e_machine == EM_PARISC
2032                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2033         {
2034           const char * result;
2035
2036           switch (elf_header.e_machine)
2037             {
2038             case EM_PARISC:
2039               result = get_parisc_dynamic_type (type);
2040               break;
2041             case EM_IA_64:
2042               result = get_ia64_dynamic_type (type);
2043               break;
2044             default:
2045               result = NULL;
2046               break;
2047             }
2048
2049           if (result != NULL)
2050             return result;
2051
2052           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2053                     type);
2054         }
2055       else
2056         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2057
2058       return buff;
2059     }
2060 }
2061
2062 static char *
2063 get_file_type (unsigned e_type)
2064 {
2065   static char buff[32];
2066
2067   switch (e_type)
2068     {
2069     case ET_NONE:       return _("NONE (None)");
2070     case ET_REL:        return _("REL (Relocatable file)");
2071     case ET_EXEC:       return _("EXEC (Executable file)");
2072     case ET_DYN:        return _("DYN (Shared object file)");
2073     case ET_CORE:       return _("CORE (Core file)");
2074
2075     default:
2076       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2077         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2078       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2079         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2080       else
2081         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2082       return buff;
2083     }
2084 }
2085
2086 static char *
2087 get_machine_name (unsigned e_machine)
2088 {
2089   static char buff[64]; /* XXX */
2090
2091   switch (e_machine)
2092     {
2093     case EM_NONE:               return _("None");
2094     case EM_AARCH64:            return "AArch64";
2095     case EM_M32:                return "WE32100";
2096     case EM_SPARC:              return "Sparc";
2097     case EM_SPU:                return "SPU";
2098     case EM_386:                return "Intel 80386";
2099     case EM_68K:                return "MC68000";
2100     case EM_88K:                return "MC88000";
2101     case EM_IAMCU:              return "Intel MCU";
2102     case EM_860:                return "Intel 80860";
2103     case EM_MIPS:               return "MIPS R3000";
2104     case EM_S370:               return "IBM System/370";
2105     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2106     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2107     case EM_PARISC:             return "HPPA";
2108     case EM_PPC_OLD:            return "Power PC (old)";
2109     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2110     case EM_960:                return "Intel 90860";
2111     case EM_PPC:                return "PowerPC";
2112     case EM_PPC64:              return "PowerPC64";
2113     case EM_FR20:               return "Fujitsu FR20";
2114     case EM_FT32:               return "FTDI FT32";
2115     case EM_RH32:               return "TRW RH32";
2116     case EM_MCORE:              return "MCORE";
2117     case EM_ARM:                return "ARM";
2118     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2119     case EM_SH:                 return "Renesas / SuperH SH";
2120     case EM_SPARCV9:            return "Sparc v9";
2121     case EM_TRICORE:            return "Siemens Tricore";
2122     case EM_ARC:                return "ARC";
2123     case EM_ARC_COMPACT:        return "ARCompact";
2124     case EM_ARC_COMPACT2:       return "ARCv2";
2125     case EM_H8_300:             return "Renesas H8/300";
2126     case EM_H8_300H:            return "Renesas H8/300H";
2127     case EM_H8S:                return "Renesas H8S";
2128     case EM_H8_500:             return "Renesas H8/500";
2129     case EM_IA_64:              return "Intel IA-64";
2130     case EM_MIPS_X:             return "Stanford MIPS-X";
2131     case EM_COLDFIRE:           return "Motorola Coldfire";
2132     case EM_ALPHA:              return "Alpha";
2133     case EM_CYGNUS_D10V:
2134     case EM_D10V:               return "d10v";
2135     case EM_CYGNUS_D30V:
2136     case EM_D30V:               return "d30v";
2137     case EM_CYGNUS_M32R:
2138     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2139     case EM_CYGNUS_V850:
2140     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2141     case EM_V850:               return "Renesas V850";
2142     case EM_CYGNUS_MN10300:
2143     case EM_MN10300:            return "mn10300";
2144     case EM_CYGNUS_MN10200:
2145     case EM_MN10200:            return "mn10200";
2146     case EM_MOXIE:              return "Moxie";
2147     case EM_CYGNUS_FR30:
2148     case EM_FR30:               return "Fujitsu FR30";
2149     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2150     case EM_PJ_OLD:
2151     case EM_PJ:                 return "picoJava";
2152     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2153     case EM_PCP:                return "Siemens PCP";
2154     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2155     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2156     case EM_STARCORE:           return "Motorola Star*Core processor";
2157     case EM_ME16:               return "Toyota ME16 processor";
2158     case EM_ST100:              return "STMicroelectronics ST100 processor";
2159     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2160     case EM_PDSP:               return "Sony DSP processor";
2161     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2162     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2163     case EM_FX66:               return "Siemens FX66 microcontroller";
2164     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2166     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2167     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2168     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2169     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2170     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2171     case EM_SVX:                return "Silicon Graphics SVx";
2172     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2173     case EM_VAX:                return "Digital VAX";
2174     case EM_VISIUM:             return "CDS VISIUMcore processor";
2175     case EM_AVR_OLD:
2176     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2177     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2178     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2179     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2180     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2181     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2182     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2183     case EM_PRISM:              return "Vitesse Prism";
2184     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2185     case EM_L1OM:               return "Intel L1OM";
2186     case EM_K1OM:               return "Intel K1OM";
2187     case EM_S390_OLD:
2188     case EM_S390:               return "IBM S/390";
2189     case EM_SCORE:              return "SUNPLUS S+Core";
2190     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2191     case EM_OR1K:               return "OpenRISC 1000";
2192     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2193     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2194     case EM_DLX:                return "OpenDLX";
2195     case EM_IP2K_OLD:
2196     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2197     case EM_IQ2000:             return "Vitesse IQ2000";
2198     case EM_XTENSA_OLD:
2199     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2200     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2201     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2202     case EM_NS32K:              return "National Semiconductor 32000 series";
2203     case EM_TPC:                return "Tenor Network TPC processor";
2204     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2205     case EM_MAX:                return "MAX Processor";
2206     case EM_CR:                 return "National Semiconductor CompactRISC";
2207     case EM_F2MC16:             return "Fujitsu F2MC16";
2208     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2209     case EM_LATTICEMICO32:      return "Lattice Mico32";
2210     case EM_M32C_OLD:
2211     case EM_M32C:               return "Renesas M32c";
2212     case EM_MT:                 return "Morpho Techologies MT processor";
2213     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2214     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2215     case EM_SEP:                return "Sharp embedded microprocessor";
2216     case EM_ARCA:               return "Arca RISC microprocessor";
2217     case EM_UNICORE:            return "Unicore";
2218     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2219     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2220     case EM_NIOS32:             return "Altera Nios";
2221     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2222     case EM_C166:
2223     case EM_XC16X:              return "Infineon Technologies xc16x";
2224     case EM_M16C:               return "Renesas M16C series microprocessors";
2225     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2226     case EM_CE:                 return "Freescale Communication Engine RISC core";
2227     case EM_TSK3000:            return "Altium TSK3000 core";
2228     case EM_RS08:               return "Freescale RS08 embedded processor";
2229     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2230     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2231     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2232     case EM_SE_C17:             return "Seiko Epson C17 family";
2233     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2234     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2235     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2236     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2238     case EM_R32C:               return "Renesas R32C series microprocessors";
2239     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2240     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2241     case EM_8051:               return "Intel 8051 and variants";
2242     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2243     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2244     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2245     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2247     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2248     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2249     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2250     case EM_CR16:
2251     case EM_MICROBLAZE:
2252     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2253     case EM_RL78:               return "Renesas RL78";
2254     case EM_RX:                 return "Renesas RX";
2255     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2256     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2257     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2258     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2259     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2260     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2261     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2262     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2263     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2264     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2265     case EM_CUDA:               return "NVIDIA CUDA architecture";
2266     case EM_XGATE:              return "Motorola XGATE embedded processor";
2267     default:
2268       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2269       return buff;
2270     }
2271 }
2272
2273 static void
2274 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2275 {
2276   unsigned eabi;
2277   int unknown = 0;
2278
2279   eabi = EF_ARM_EABI_VERSION (e_flags);
2280   e_flags &= ~ EF_ARM_EABIMASK;
2281
2282   /* Handle "generic" ARM flags.  */
2283   if (e_flags & EF_ARM_RELEXEC)
2284     {
2285       strcat (buf, ", relocatable executable");
2286       e_flags &= ~ EF_ARM_RELEXEC;
2287     }
2288
2289   /* Now handle EABI specific flags.  */
2290   switch (eabi)
2291     {
2292     default:
2293       strcat (buf, ", <unrecognized EABI>");
2294       if (e_flags)
2295         unknown = 1;
2296       break;
2297
2298     case EF_ARM_EABI_VER1:
2299       strcat (buf, ", Version1 EABI");
2300       while (e_flags)
2301         {
2302           unsigned flag;
2303
2304           /* Process flags one bit at a time.  */
2305           flag = e_flags & - e_flags;
2306           e_flags &= ~ flag;
2307
2308           switch (flag)
2309             {
2310             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2311               strcat (buf, ", sorted symbol tables");
2312               break;
2313
2314             default:
2315               unknown = 1;
2316               break;
2317             }
2318         }
2319       break;
2320
2321     case EF_ARM_EABI_VER2:
2322       strcat (buf, ", Version2 EABI");
2323       while (e_flags)
2324         {
2325           unsigned flag;
2326
2327           /* Process flags one bit at a time.  */
2328           flag = e_flags & - e_flags;
2329           e_flags &= ~ flag;
2330
2331           switch (flag)
2332             {
2333             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2334               strcat (buf, ", sorted symbol tables");
2335               break;
2336
2337             case EF_ARM_DYNSYMSUSESEGIDX:
2338               strcat (buf, ", dynamic symbols use segment index");
2339               break;
2340
2341             case EF_ARM_MAPSYMSFIRST:
2342               strcat (buf, ", mapping symbols precede others");
2343               break;
2344
2345             default:
2346               unknown = 1;
2347               break;
2348             }
2349         }
2350       break;
2351
2352     case EF_ARM_EABI_VER3:
2353       strcat (buf, ", Version3 EABI");
2354       break;
2355
2356     case EF_ARM_EABI_VER4:
2357       strcat (buf, ", Version4 EABI");
2358       while (e_flags)
2359         {
2360           unsigned flag;
2361
2362           /* Process flags one bit at a time.  */
2363           flag = e_flags & - e_flags;
2364           e_flags &= ~ flag;
2365
2366           switch (flag)
2367             {
2368             case EF_ARM_BE8:
2369               strcat (buf, ", BE8");
2370               break;
2371
2372             case EF_ARM_LE8:
2373               strcat (buf, ", LE8");
2374               break;
2375
2376             default:
2377               unknown = 1;
2378               break;
2379             }
2380       break;
2381         }
2382       break;
2383
2384     case EF_ARM_EABI_VER5:
2385       strcat (buf, ", Version5 EABI");
2386       while (e_flags)
2387         {
2388           unsigned flag;
2389
2390           /* Process flags one bit at a time.  */
2391           flag = e_flags & - e_flags;
2392           e_flags &= ~ flag;
2393
2394           switch (flag)
2395             {
2396             case EF_ARM_BE8:
2397               strcat (buf, ", BE8");
2398               break;
2399
2400             case EF_ARM_LE8:
2401               strcat (buf, ", LE8");
2402               break;
2403
2404             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2405               strcat (buf, ", soft-float ABI");
2406               break;
2407
2408             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2409               strcat (buf, ", hard-float ABI");
2410               break;
2411
2412             default:
2413               unknown = 1;
2414               break;
2415             }
2416         }
2417       break;
2418
2419     case EF_ARM_EABI_UNKNOWN:
2420       strcat (buf, ", GNU EABI");
2421       while (e_flags)
2422         {
2423           unsigned flag;
2424
2425           /* Process flags one bit at a time.  */
2426           flag = e_flags & - e_flags;
2427           e_flags &= ~ flag;
2428
2429           switch (flag)
2430             {
2431             case EF_ARM_INTERWORK:
2432               strcat (buf, ", interworking enabled");
2433               break;
2434
2435             case EF_ARM_APCS_26:
2436               strcat (buf, ", uses APCS/26");
2437               break;
2438
2439             case EF_ARM_APCS_FLOAT:
2440               strcat (buf, ", uses APCS/float");
2441               break;
2442
2443             case EF_ARM_PIC:
2444               strcat (buf, ", position independent");
2445               break;
2446
2447             case EF_ARM_ALIGN8:
2448               strcat (buf, ", 8 bit structure alignment");
2449               break;
2450
2451             case EF_ARM_NEW_ABI:
2452               strcat (buf, ", uses new ABI");
2453               break;
2454
2455             case EF_ARM_OLD_ABI:
2456               strcat (buf, ", uses old ABI");
2457               break;
2458
2459             case EF_ARM_SOFT_FLOAT:
2460               strcat (buf, ", software FP");
2461               break;
2462
2463             case EF_ARM_VFP_FLOAT:
2464               strcat (buf, ", VFP");
2465               break;
2466
2467             case EF_ARM_MAVERICK_FLOAT:
2468               strcat (buf, ", Maverick FP");
2469               break;
2470
2471             default:
2472               unknown = 1;
2473               break;
2474             }
2475         }
2476     }
2477
2478   if (unknown)
2479     strcat (buf,_(", <unknown>"));
2480 }
2481
2482 static void
2483 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2484 {
2485   --size; /* Leave space for null terminator.  */
2486
2487   switch (e_flags & EF_AVR_MACH)
2488     {
2489     case E_AVR_MACH_AVR1:
2490       strncat (buf, ", avr:1", size);
2491       break;
2492     case E_AVR_MACH_AVR2:
2493       strncat (buf, ", avr:2", size);
2494       break;
2495     case E_AVR_MACH_AVR25:
2496       strncat (buf, ", avr:25", size);
2497       break;
2498     case E_AVR_MACH_AVR3:
2499       strncat (buf, ", avr:3", size);
2500       break;
2501     case E_AVR_MACH_AVR31:
2502       strncat (buf, ", avr:31", size);
2503       break;
2504     case E_AVR_MACH_AVR35:
2505       strncat (buf, ", avr:35", size);
2506       break;
2507     case E_AVR_MACH_AVR4:
2508       strncat (buf, ", avr:4", size);
2509       break;
2510     case E_AVR_MACH_AVR5:
2511       strncat (buf, ", avr:5", size);
2512       break;
2513     case E_AVR_MACH_AVR51:
2514       strncat (buf, ", avr:51", size);
2515       break;
2516     case E_AVR_MACH_AVR6:
2517       strncat (buf, ", avr:6", size);
2518       break;
2519     case E_AVR_MACH_AVRTINY:
2520       strncat (buf, ", avr:100", size);
2521       break;
2522     case E_AVR_MACH_XMEGA1:
2523       strncat (buf, ", avr:101", size);
2524       break;
2525     case E_AVR_MACH_XMEGA2:
2526       strncat (buf, ", avr:102", size);
2527       break;
2528     case E_AVR_MACH_XMEGA3:
2529       strncat (buf, ", avr:103", size);
2530       break;
2531     case E_AVR_MACH_XMEGA4:
2532       strncat (buf, ", avr:104", size);
2533       break;
2534     case E_AVR_MACH_XMEGA5:
2535       strncat (buf, ", avr:105", size);
2536       break;
2537     case E_AVR_MACH_XMEGA6:
2538       strncat (buf, ", avr:106", size);
2539       break;
2540     case E_AVR_MACH_XMEGA7:
2541       strncat (buf, ", avr:107", size);
2542       break;
2543     default:
2544       strncat (buf, ", avr:<unknown>", size);
2545       break;
2546     }
2547
2548   size -= strlen (buf);
2549   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550     strncat (buf, ", link-relax", size);
2551 }
2552
2553 static void
2554 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2555 {
2556   unsigned abi;
2557   unsigned arch;
2558   unsigned config;
2559   unsigned version;
2560   int has_fpu = 0;
2561   int r = 0;
2562
2563   static const char *ABI_STRINGS[] =
2564   {
2565     "ABI v0", /* use r5 as return register; only used in N1213HC */
2566     "ABI v1", /* use r0 as return register */
2567     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568     "ABI v2fp", /* for FPU */
2569     "AABI",
2570     "ABI2 FP+"
2571   };
2572   static const char *VER_STRINGS[] =
2573   {
2574     "Andes ELF V1.3 or older",
2575     "Andes ELF V1.3.1",
2576     "Andes ELF V1.4"
2577   };
2578   static const char *ARCH_STRINGS[] =
2579   {
2580     "",
2581     "Andes Star v1.0",
2582     "Andes Star v2.0",
2583     "Andes Star v3.0",
2584     "Andes Star v3.0m"
2585   };
2586
2587   abi = EF_NDS_ABI & e_flags;
2588   arch = EF_NDS_ARCH & e_flags;
2589   config = EF_NDS_INST & e_flags;
2590   version = EF_NDS32_ELF_VERSION & e_flags;
2591
2592   memset (buf, 0, size);
2593
2594   switch (abi)
2595     {
2596     case E_NDS_ABI_V0:
2597     case E_NDS_ABI_V1:
2598     case E_NDS_ABI_V2:
2599     case E_NDS_ABI_V2FP:
2600     case E_NDS_ABI_AABI:
2601     case E_NDS_ABI_V2FP_PLUS:
2602       /* In case there are holes in the array.  */
2603       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2604       break;
2605
2606     default:
2607       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2608       break;
2609     }
2610
2611   switch (version)
2612     {
2613     case E_NDS32_ELF_VER_1_2:
2614     case E_NDS32_ELF_VER_1_3:
2615     case E_NDS32_ELF_VER_1_4:
2616       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2617       break;
2618
2619     default:
2620       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2621       break;
2622     }
2623
2624   if (E_NDS_ABI_V0 == abi)
2625     {
2626       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2627       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628       if (arch == E_NDS_ARCH_STAR_V1_0)
2629         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2630       return;
2631     }
2632
2633   switch (arch)
2634     {
2635     case E_NDS_ARCH_STAR_V1_0:
2636     case E_NDS_ARCH_STAR_V2_0:
2637     case E_NDS_ARCH_STAR_V3_0:
2638     case E_NDS_ARCH_STAR_V3_M:
2639       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2640       break;
2641
2642     default:
2643       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644       /* ARCH version determines how the e_flags are interpreted.
2645          If it is unknown, we cannot proceed.  */
2646       return;
2647     }
2648
2649   /* Newer ABI; Now handle architecture specific flags.  */
2650   if (arch == E_NDS_ARCH_STAR_V1_0)
2651     {
2652       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2654
2655       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656         r += snprintf (buf + r, size -r, ", MAC");
2657
2658       if (config & E_NDS32_HAS_DIV_INST)
2659         r += snprintf (buf + r, size -r, ", DIV");
2660
2661       if (config & E_NDS32_HAS_16BIT_INST)
2662         r += snprintf (buf + r, size -r, ", 16b");
2663     }
2664   else
2665     {
2666       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2667         {
2668           if (version <= E_NDS32_ELF_VER_1_3)
2669             r += snprintf (buf + r, size -r, ", [B8]");
2670           else
2671             r += snprintf (buf + r, size -r, ", EX9");
2672         }
2673
2674       if (config & E_NDS32_HAS_MAC_DX_INST)
2675         r += snprintf (buf + r, size -r, ", MAC_DX");
2676
2677       if (config & E_NDS32_HAS_DIV_DX_INST)
2678         r += snprintf (buf + r, size -r, ", DIV_DX");
2679
2680       if (config & E_NDS32_HAS_16BIT_INST)
2681         {
2682           if (version <= E_NDS32_ELF_VER_1_3)
2683             r += snprintf (buf + r, size -r, ", 16b");
2684           else
2685             r += snprintf (buf + r, size -r, ", IFC");
2686         }
2687     }
2688
2689   if (config & E_NDS32_HAS_EXT_INST)
2690     r += snprintf (buf + r, size -r, ", PERF1");
2691
2692   if (config & E_NDS32_HAS_EXT2_INST)
2693     r += snprintf (buf + r, size -r, ", PERF2");
2694
2695   if (config & E_NDS32_HAS_FPU_INST)
2696     {
2697       has_fpu = 1;
2698       r += snprintf (buf + r, size -r, ", FPU_SP");
2699     }
2700
2701   if (config & E_NDS32_HAS_FPU_DP_INST)
2702     {
2703       has_fpu = 1;
2704       r += snprintf (buf + r, size -r, ", FPU_DP");
2705     }
2706
2707   if (config & E_NDS32_HAS_FPU_MAC_INST)
2708     {
2709       has_fpu = 1;
2710       r += snprintf (buf + r, size -r, ", FPU_MAC");
2711     }
2712
2713   if (has_fpu)
2714     {
2715       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2716         {
2717         case E_NDS32_FPU_REG_8SP_4DP:
2718           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2719           break;
2720         case E_NDS32_FPU_REG_16SP_8DP:
2721           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2722           break;
2723         case E_NDS32_FPU_REG_32SP_16DP:
2724           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2725           break;
2726         case E_NDS32_FPU_REG_32SP_32DP:
2727           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2728           break;
2729         }
2730     }
2731
2732   if (config & E_NDS32_HAS_AUDIO_INST)
2733     r += snprintf (buf + r, size -r, ", AUDIO");
2734
2735   if (config & E_NDS32_HAS_STRING_INST)
2736     r += snprintf (buf + r, size -r, ", STR");
2737
2738   if (config & E_NDS32_HAS_REDUCED_REGS)
2739     r += snprintf (buf + r, size -r, ", 16REG");
2740
2741   if (config & E_NDS32_HAS_VIDEO_INST)
2742     {
2743       if (version <= E_NDS32_ELF_VER_1_3)
2744         r += snprintf (buf + r, size -r, ", VIDEO");
2745       else
2746         r += snprintf (buf + r, size -r, ", SATURATION");
2747     }
2748
2749   if (config & E_NDS32_HAS_ENCRIPT_INST)
2750     r += snprintf (buf + r, size -r, ", ENCRP");
2751
2752   if (config & E_NDS32_HAS_L2C_INST)
2753     r += snprintf (buf + r, size -r, ", L2C");
2754 }
2755
2756 static char *
2757 get_machine_flags (unsigned e_flags, unsigned e_machine)
2758 {
2759   static char buf[1024];
2760
2761   buf[0] = '\0';
2762
2763   if (e_flags)
2764     {
2765       switch (e_machine)
2766         {
2767         default:
2768           break;
2769
2770         case EM_ARC_COMPACT2:
2771           switch (e_flags & EF_ARC_MACH_MSK)
2772             {
2773             case EF_ARC_CPU_ARCV2EM:
2774               strcat (buf, ", ARC EM");
2775               break;
2776             case EF_ARC_CPU_ARCV2HS:
2777               strcat (buf, ", ARC HS");
2778               break;
2779             case EF_ARC_CPU_GENERIC:
2780               strcat (buf, ", ARC generic");
2781               break;
2782             case E_ARC_MACH_ARC600:
2783               strcat (buf, ", ARC600");
2784               break;
2785             case E_ARC_MACH_ARC601:
2786               strcat (buf, ", ARC601");
2787               break;
2788             case E_ARC_MACH_ARC700:
2789               strcat (buf, ", ARC700");
2790               break;
2791             default:
2792               strcat (buf, ", unrecognized cpu flag for ARCv2");
2793               break;
2794             }
2795           switch (e_flags & EF_ARC_OSABI_MSK)
2796             {
2797             case E_ARC_OSABI_ORIG:
2798               strcat (buf, ", (ABI:legacy)");
2799               break;
2800             case E_ARC_OSABI_V2:
2801               strcat (buf, ", (ABI:v2)");
2802               break;
2803               /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2804             case E_ARC_OSABI_V3:
2805               strcat (buf, ", v3 no-legacy-syscalls ABI");
2806               break;
2807             default:
2808               strcat (buf, ", unrecognised ARC OSABI flag");
2809               break;
2810             }
2811           break;
2812
2813         case EM_ARC_COMPACT:
2814           switch (e_flags & EF_ARC_MACH_MSK)
2815             {
2816             case E_ARC_MACH_ARC600:
2817               strcat (buf, ", ARC 600");
2818               break;
2819             case E_ARC_MACH_ARC601:
2820               strcat (buf, ", ARC 601");
2821               break;
2822             case E_ARC_MACH_ARC700:
2823               strcat (buf, ", ARC 700");
2824               break;
2825             default:
2826               strcat (buf, ", Generic ARCompact");
2827               break;
2828             }
2829           switch (e_flags & EF_ARC_OSABI_MSK)
2830             {
2831             case E_ARC_OSABI_ORIG:
2832               strcat (buf, ", legacy syscall ABI");
2833               break;
2834             case E_ARC_OSABI_V2:
2835               /* For 3.2+ Linux kernels which use asm-generic
2836                  hdrs.  */
2837               strcat (buf, ", v2 syscall ABI");
2838               break;
2839             case E_ARC_OSABI_V3:
2840               /* Upstream 3.9+ kernels which don't use any legacy
2841                  syscalls.  */
2842               strcat (buf, ", v3 no-legacy-syscalls ABI");
2843               break;
2844             }
2845           break;
2846
2847         case EM_ARM:
2848           decode_ARM_machine_flags (e_flags, buf);
2849           break;
2850
2851         case EM_AVR:
2852           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2853           break;
2854
2855         case EM_BLACKFIN:
2856           if (e_flags & EF_BFIN_PIC)
2857             strcat (buf, ", PIC");
2858
2859           if (e_flags & EF_BFIN_FDPIC)
2860             strcat (buf, ", FDPIC");
2861
2862           if (e_flags & EF_BFIN_CODE_IN_L1)
2863             strcat (buf, ", code in L1");
2864
2865           if (e_flags & EF_BFIN_DATA_IN_L1)
2866             strcat (buf, ", data in L1");
2867
2868           break;
2869
2870         case EM_CYGNUS_FRV:
2871           switch (e_flags & EF_FRV_CPU_MASK)
2872             {
2873             case EF_FRV_CPU_GENERIC:
2874               break;
2875
2876             default:
2877               strcat (buf, ", fr???");
2878               break;
2879
2880             case EF_FRV_CPU_FR300:
2881               strcat (buf, ", fr300");
2882               break;
2883
2884             case EF_FRV_CPU_FR400:
2885               strcat (buf, ", fr400");
2886               break;
2887             case EF_FRV_CPU_FR405:
2888               strcat (buf, ", fr405");
2889               break;
2890
2891             case EF_FRV_CPU_FR450:
2892               strcat (buf, ", fr450");
2893               break;
2894
2895             case EF_FRV_CPU_FR500:
2896               strcat (buf, ", fr500");
2897               break;
2898             case EF_FRV_CPU_FR550:
2899               strcat (buf, ", fr550");
2900               break;
2901
2902             case EF_FRV_CPU_SIMPLE:
2903               strcat (buf, ", simple");
2904               break;
2905             case EF_FRV_CPU_TOMCAT:
2906               strcat (buf, ", tomcat");
2907               break;
2908             }
2909           break;
2910
2911         case EM_68K:
2912           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2913             strcat (buf, ", m68000");
2914           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2915             strcat (buf, ", cpu32");
2916           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2917             strcat (buf, ", fido_a");
2918           else
2919             {
2920               char const * isa = _("unknown");
2921               char const * mac = _("unknown mac");
2922               char const * additional = NULL;
2923
2924               switch (e_flags & EF_M68K_CF_ISA_MASK)
2925                 {
2926                 case EF_M68K_CF_ISA_A_NODIV:
2927                   isa = "A";
2928                   additional = ", nodiv";
2929                   break;
2930                 case EF_M68K_CF_ISA_A:
2931                   isa = "A";
2932                   break;
2933                 case EF_M68K_CF_ISA_A_PLUS:
2934                   isa = "A+";
2935                   break;
2936                 case EF_M68K_CF_ISA_B_NOUSP:
2937                   isa = "B";
2938                   additional = ", nousp";
2939                   break;
2940                 case EF_M68K_CF_ISA_B:
2941                   isa = "B";
2942                   break;
2943                 case EF_M68K_CF_ISA_C:
2944                   isa = "C";
2945                   break;
2946                 case EF_M68K_CF_ISA_C_NODIV:
2947                   isa = "C";
2948                   additional = ", nodiv";
2949                   break;
2950                 }
2951               strcat (buf, ", cf, isa ");
2952               strcat (buf, isa);
2953               if (additional)
2954                 strcat (buf, additional);
2955               if (e_flags & EF_M68K_CF_FLOAT)
2956                 strcat (buf, ", float");
2957               switch (e_flags & EF_M68K_CF_MAC_MASK)
2958                 {
2959                 case 0:
2960                   mac = NULL;
2961                   break;
2962                 case EF_M68K_CF_MAC:
2963                   mac = "mac";
2964                   break;
2965                 case EF_M68K_CF_EMAC:
2966                   mac = "emac";
2967                   break;
2968                 case EF_M68K_CF_EMAC_B:
2969                   mac = "emac_b";
2970                   break;
2971                 }
2972               if (mac)
2973                 {
2974                   strcat (buf, ", ");
2975                   strcat (buf, mac);
2976                 }
2977             }
2978           break;
2979
2980         case EM_CYGNUS_MEP:
2981           switch (e_flags & EF_MEP_CPU_MASK)
2982             {
2983             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2984             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2985             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2986             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2987             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2988             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2989             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2990             }
2991
2992           switch (e_flags & EF_MEP_COP_MASK)
2993             {
2994             case EF_MEP_COP_NONE: break;
2995             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2996             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2997             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2998             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2999             default: strcat (buf, _("<unknown MeP copro type>")); break;
3000             }
3001
3002           if (e_flags & EF_MEP_LIBRARY)
3003             strcat (buf, ", Built for Library");
3004
3005           if (e_flags & EF_MEP_INDEX_MASK)
3006             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3007                      e_flags & EF_MEP_INDEX_MASK);
3008
3009           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3010             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3011                      e_flags & ~ EF_MEP_ALL_FLAGS);
3012           break;
3013
3014         case EM_PPC:
3015           if (e_flags & EF_PPC_EMB)
3016             strcat (buf, ", emb");
3017
3018           if (e_flags & EF_PPC_RELOCATABLE)
3019             strcat (buf, _(", relocatable"));
3020
3021           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3022             strcat (buf, _(", relocatable-lib"));
3023           break;
3024
3025         case EM_PPC64:
3026           if (e_flags & EF_PPC64_ABI)
3027             {
3028               char abi[] = ", abiv0";
3029
3030               abi[6] += e_flags & EF_PPC64_ABI;
3031               strcat (buf, abi);
3032             }
3033           break;
3034
3035         case EM_V800:
3036           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3037             strcat (buf, ", RH850 ABI");
3038
3039           if (e_flags & EF_V800_850E3)
3040             strcat (buf, ", V3 architecture");
3041
3042           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3043             strcat (buf, ", FPU not used");
3044
3045           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3046             strcat (buf, ", regmode: COMMON");
3047
3048           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3049             strcat (buf, ", r4 not used");
3050
3051           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3052             strcat (buf, ", r30 not used");
3053
3054           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3055             strcat (buf, ", r5 not used");
3056
3057           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3058             strcat (buf, ", r2 not used");
3059
3060           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3061             {
3062               switch (e_flags & - e_flags)
3063                 {
3064                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3065                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3066                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3067                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3068                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3069                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3070                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3071                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3072                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3073                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3074                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3075                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3076                 default: break;
3077                 }
3078             }
3079           break;
3080
3081         case EM_V850:
3082         case EM_CYGNUS_V850:
3083           switch (e_flags & EF_V850_ARCH)
3084             {
3085             case E_V850E3V5_ARCH:
3086               strcat (buf, ", v850e3v5");
3087               break;
3088             case E_V850E2V3_ARCH:
3089               strcat (buf, ", v850e2v3");
3090               break;
3091             case E_V850E2_ARCH:
3092               strcat (buf, ", v850e2");
3093               break;
3094             case E_V850E1_ARCH:
3095               strcat (buf, ", v850e1");
3096               break;
3097             case E_V850E_ARCH:
3098               strcat (buf, ", v850e");
3099               break;
3100             case E_V850_ARCH:
3101               strcat (buf, ", v850");
3102               break;
3103             default:
3104               strcat (buf, _(", unknown v850 architecture variant"));
3105               break;
3106             }
3107           break;
3108
3109         case EM_M32R:
3110         case EM_CYGNUS_M32R:
3111           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3112             strcat (buf, ", m32r");
3113           break;
3114
3115         case EM_MIPS:
3116         case EM_MIPS_RS3_LE:
3117           if (e_flags & EF_MIPS_NOREORDER)
3118             strcat (buf, ", noreorder");
3119
3120           if (e_flags & EF_MIPS_PIC)
3121             strcat (buf, ", pic");
3122
3123           if (e_flags & EF_MIPS_CPIC)
3124             strcat (buf, ", cpic");
3125
3126           if (e_flags & EF_MIPS_UCODE)
3127             strcat (buf, ", ugen_reserved");
3128
3129           if (e_flags & EF_MIPS_ABI2)
3130             strcat (buf, ", abi2");
3131
3132           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3133             strcat (buf, ", odk first");
3134
3135           if (e_flags & EF_MIPS_32BITMODE)
3136             strcat (buf, ", 32bitmode");
3137
3138           if (e_flags & EF_MIPS_NAN2008)
3139             strcat (buf, ", nan2008");
3140
3141           if (e_flags & EF_MIPS_FP64)
3142             strcat (buf, ", fp64");
3143
3144           switch ((e_flags & EF_MIPS_MACH))
3145             {
3146             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3147             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3148             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3149             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3150             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3151             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3152             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3153             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3154             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3155             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3156             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3157             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3158             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3159             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3160             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3161             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3162             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3163             case 0:
3164             /* We simply ignore the field in this case to avoid confusion:
3165                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3166                extension.  */
3167               break;
3168             default: strcat (buf, _(", unknown CPU")); break;
3169             }
3170
3171           switch ((e_flags & EF_MIPS_ABI))
3172             {
3173             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3174             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3175             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3176             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3177             case 0:
3178             /* We simply ignore the field in this case to avoid confusion:
3179                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3180                This means it is likely to be an o32 file, but not for
3181                sure.  */
3182               break;
3183             default: strcat (buf, _(", unknown ABI")); break;
3184             }
3185
3186           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3187             strcat (buf, ", mdmx");
3188
3189           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3190             strcat (buf, ", mips16");
3191
3192           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3193             strcat (buf, ", micromips");
3194
3195           switch ((e_flags & EF_MIPS_ARCH))
3196             {
3197             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3198             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3199             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3200             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3201             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3202             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3203             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3204             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3205             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3206             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3207             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3208             default: strcat (buf, _(", unknown ISA")); break;
3209             }
3210           break;
3211
3212         case EM_NDS32:
3213           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3214           break;
3215
3216         case EM_SH:
3217           switch ((e_flags & EF_SH_MACH_MASK))
3218             {
3219             case EF_SH1: strcat (buf, ", sh1"); break;
3220             case EF_SH2: strcat (buf, ", sh2"); break;
3221             case EF_SH3: strcat (buf, ", sh3"); break;
3222             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3223             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3224             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3225             case EF_SH3E: strcat (buf, ", sh3e"); break;
3226             case EF_SH4: strcat (buf, ", sh4"); break;
3227             case EF_SH5: strcat (buf, ", sh5"); break;
3228             case EF_SH2E: strcat (buf, ", sh2e"); break;
3229             case EF_SH4A: strcat (buf, ", sh4a"); break;
3230             case EF_SH2A: strcat (buf, ", sh2a"); break;
3231             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3232             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3233             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3234             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3235             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3236             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3237             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3238             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3239             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3240             default: strcat (buf, _(", unknown ISA")); break;
3241             }
3242
3243           if (e_flags & EF_SH_PIC)
3244             strcat (buf, ", pic");
3245
3246           if (e_flags & EF_SH_FDPIC)
3247             strcat (buf, ", fdpic");
3248           break;
3249
3250         case EM_OR1K:
3251           if (e_flags & EF_OR1K_NODELAY)
3252             strcat (buf, ", no delay");
3253           break;
3254
3255         case EM_SPARCV9:
3256           if (e_flags & EF_SPARC_32PLUS)
3257             strcat (buf, ", v8+");
3258
3259           if (e_flags & EF_SPARC_SUN_US1)
3260             strcat (buf, ", ultrasparcI");
3261
3262           if (e_flags & EF_SPARC_SUN_US3)
3263             strcat (buf, ", ultrasparcIII");
3264
3265           if (e_flags & EF_SPARC_HAL_R1)
3266             strcat (buf, ", halr1");
3267
3268           if (e_flags & EF_SPARC_LEDATA)
3269             strcat (buf, ", ledata");
3270
3271           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3272             strcat (buf, ", tso");
3273
3274           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3275             strcat (buf, ", pso");
3276
3277           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3278             strcat (buf, ", rmo");
3279           break;
3280
3281         case EM_PARISC:
3282           switch (e_flags & EF_PARISC_ARCH)
3283             {
3284             case EFA_PARISC_1_0:
3285               strcpy (buf, ", PA-RISC 1.0");
3286               break;
3287             case EFA_PARISC_1_1:
3288               strcpy (buf, ", PA-RISC 1.1");
3289               break;
3290             case EFA_PARISC_2_0:
3291               strcpy (buf, ", PA-RISC 2.0");
3292               break;
3293             default:
3294               break;
3295             }
3296           if (e_flags & EF_PARISC_TRAPNIL)
3297             strcat (buf, ", trapnil");
3298           if (e_flags & EF_PARISC_EXT)
3299             strcat (buf, ", ext");
3300           if (e_flags & EF_PARISC_LSB)
3301             strcat (buf, ", lsb");
3302           if (e_flags & EF_PARISC_WIDE)
3303             strcat (buf, ", wide");
3304           if (e_flags & EF_PARISC_NO_KABP)
3305             strcat (buf, ", no kabp");
3306           if (e_flags & EF_PARISC_LAZYSWAP)
3307             strcat (buf, ", lazyswap");
3308           break;
3309
3310         case EM_PJ:
3311         case EM_PJ_OLD:
3312           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3313             strcat (buf, ", new calling convention");
3314
3315           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3316             strcat (buf, ", gnu calling convention");
3317           break;
3318
3319         case EM_IA_64:
3320           if ((e_flags & EF_IA_64_ABI64))
3321             strcat (buf, ", 64-bit");
3322           else
3323             strcat (buf, ", 32-bit");
3324           if ((e_flags & EF_IA_64_REDUCEDFP))
3325             strcat (buf, ", reduced fp model");
3326           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3327             strcat (buf, ", no function descriptors, constant gp");
3328           else if ((e_flags & EF_IA_64_CONS_GP))
3329             strcat (buf, ", constant gp");
3330           if ((e_flags & EF_IA_64_ABSOLUTE))
3331             strcat (buf, ", absolute");
3332           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3333             {
3334               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3335                 strcat (buf, ", vms_linkages");
3336               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3337                 {
3338                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3339                   break;
3340                 case EF_IA_64_VMS_COMCOD_WARNING:
3341                   strcat (buf, ", warning");
3342                   break;
3343                 case EF_IA_64_VMS_COMCOD_ERROR:
3344                   strcat (buf, ", error");
3345                   break;
3346                 case EF_IA_64_VMS_COMCOD_ABORT:
3347                   strcat (buf, ", abort");
3348                   break;
3349                 default:
3350                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3351                         e_flags & EF_IA_64_VMS_COMCOD);
3352                   strcat (buf, ", <unknown>");
3353                 }
3354             }
3355           break;
3356
3357         case EM_VAX:
3358           if ((e_flags & EF_VAX_NONPIC))
3359             strcat (buf, ", non-PIC");
3360           if ((e_flags & EF_VAX_DFLOAT))
3361             strcat (buf, ", D-Float");
3362           if ((e_flags & EF_VAX_GFLOAT))
3363             strcat (buf, ", G-Float");
3364           break;
3365
3366         case EM_VISIUM:
3367           if (e_flags & EF_VISIUM_ARCH_MCM)
3368             strcat (buf, ", mcm");
3369           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3370             strcat (buf, ", mcm24");
3371           if (e_flags & EF_VISIUM_ARCH_GR6)
3372             strcat (buf, ", gr6");
3373           break;
3374
3375         case EM_RL78:
3376           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3377             {
3378             case E_FLAG_RL78_ANY_CPU: break;
3379             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3380             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3381             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3382             }
3383           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3384             strcat (buf, ", 64-bit doubles");
3385           break;
3386
3387         case EM_RX:
3388           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3389             strcat (buf, ", 64-bit doubles");
3390           if (e_flags & E_FLAG_RX_DSP)
3391             strcat (buf, ", dsp");
3392           if (e_flags & E_FLAG_RX_PID)
3393             strcat (buf, ", pid");
3394           if (e_flags & E_FLAG_RX_ABI)
3395             strcat (buf, ", RX ABI");
3396           if (e_flags & E_FLAG_RX_SINSNS_SET)
3397             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3398                     ? ", uses String instructions" : ", bans String instructions");
3399           if (e_flags & E_FLAG_RX_V2)
3400             strcat (buf, ", V2");
3401           break;
3402
3403         case EM_S390:
3404           if (e_flags & EF_S390_HIGH_GPRS)
3405             strcat (buf, ", highgprs");
3406           break;
3407
3408         case EM_TI_C6000:
3409           if ((e_flags & EF_C6000_REL))
3410             strcat (buf, ", relocatable module");
3411           break;
3412
3413         case EM_MSP430:
3414           strcat (buf, _(": architecture variant: "));
3415           switch (e_flags & EF_MSP430_MACH)
3416             {
3417             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3418             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3419             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3420             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3421             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3422             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3423             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3424             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3425             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3426             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3427             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3428             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3429             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3430             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3431             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3432             default:
3433               strcat (buf, _(": unknown")); break;
3434             }
3435
3436           if (e_flags & ~ EF_MSP430_MACH)
3437             strcat (buf, _(": unknown extra flag bits also present"));
3438         }
3439     }
3440
3441   return buf;
3442 }
3443
3444 static const char *
3445 get_osabi_name (unsigned int osabi)
3446 {
3447   static char buff[32];
3448
3449   switch (osabi)
3450     {
3451     case ELFOSABI_NONE:         return "UNIX - System V";
3452     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3453     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3454     case ELFOSABI_GNU:          return "UNIX - GNU";
3455     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3456     case ELFOSABI_AIX:          return "UNIX - AIX";
3457     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3458     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3459     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3460     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3461     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3462     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3463     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3464     case ELFOSABI_AROS:         return "AROS";
3465     case ELFOSABI_FENIXOS:      return "FenixOS";
3466     default:
3467       if (osabi >= 64)
3468         switch (elf_header.e_machine)
3469           {
3470           case EM_ARM:
3471             switch (osabi)
3472               {
3473               case ELFOSABI_ARM:        return "ARM";
3474               default:
3475                 break;
3476               }
3477             break;
3478
3479           case EM_MSP430:
3480           case EM_MSP430_OLD:
3481           case EM_VISIUM:
3482             switch (osabi)
3483               {
3484               case ELFOSABI_STANDALONE: return _("Standalone App");
3485               default:
3486                 break;
3487               }
3488             break;
3489
3490           case EM_TI_C6000:
3491             switch (osabi)
3492               {
3493               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3494               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3495               default:
3496                 break;
3497               }
3498             break;
3499
3500           default:
3501             break;
3502           }
3503       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3504       return buff;
3505     }
3506 }
3507
3508 static const char *
3509 get_aarch64_segment_type (unsigned long type)
3510 {
3511   switch (type)
3512     {
3513     case PT_AARCH64_ARCHEXT:
3514       return "AARCH64_ARCHEXT";
3515     default:
3516       break;
3517     }
3518
3519   return NULL;
3520 }
3521
3522 static const char *
3523 get_arm_segment_type (unsigned long type)
3524 {
3525   switch (type)
3526     {
3527     case PT_ARM_EXIDX:
3528       return "EXIDX";
3529     default:
3530       break;
3531     }
3532
3533   return NULL;
3534 }
3535
3536 static const char *
3537 get_mips_segment_type (unsigned long type)
3538 {
3539   switch (type)
3540     {
3541     case PT_MIPS_REGINFO:
3542       return "REGINFO";
3543     case PT_MIPS_RTPROC:
3544       return "RTPROC";
3545     case PT_MIPS_OPTIONS:
3546       return "OPTIONS";
3547     case PT_MIPS_ABIFLAGS:
3548       return "ABIFLAGS";
3549     default:
3550       break;
3551     }
3552
3553   return NULL;
3554 }
3555
3556 static const char *
3557 get_parisc_segment_type (unsigned long type)
3558 {
3559   switch (type)
3560     {
3561     case PT_HP_TLS:             return "HP_TLS";
3562     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3563     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3564     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3565     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3566     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3567     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3568     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3569     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3570     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3571     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3572     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3573     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3574     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3575     case PT_HP_STACK:           return "HP_STACK";
3576     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3577     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3578     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3579     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3580     default:
3581       break;
3582     }
3583
3584   return NULL;
3585 }
3586
3587 static const char *
3588 get_ia64_segment_type (unsigned long type)
3589 {
3590   switch (type)
3591     {
3592     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3593     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3594     case PT_HP_TLS:             return "HP_TLS";
3595     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3596     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3597     case PT_IA_64_HP_STACK:     return "HP_STACK";
3598     default:
3599       break;
3600     }
3601
3602   return NULL;
3603 }
3604
3605 static const char *
3606 get_tic6x_segment_type (unsigned long type)
3607 {
3608   switch (type)
3609     {
3610     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3611     default:
3612       break;
3613     }
3614
3615   return NULL;
3616 }
3617
3618 static const char *
3619 get_segment_type (unsigned long p_type)
3620 {
3621   static char buff[32];
3622
3623   switch (p_type)
3624     {
3625     case PT_NULL:       return "NULL";
3626     case PT_LOAD:       return "LOAD";
3627     case PT_DYNAMIC:    return "DYNAMIC";
3628     case PT_INTERP:     return "INTERP";
3629     case PT_NOTE:       return "NOTE";
3630     case PT_SHLIB:      return "SHLIB";
3631     case PT_PHDR:       return "PHDR";
3632     case PT_TLS:        return "TLS";
3633
3634     case PT_GNU_EH_FRAME:
3635                         return "GNU_EH_FRAME";
3636     case PT_GNU_STACK:  return "GNU_STACK";
3637     case PT_GNU_RELRO:  return "GNU_RELRO";
3638
3639     default:
3640       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3641         {
3642           const char * result;
3643
3644           switch (elf_header.e_machine)
3645             {
3646             case EM_AARCH64:
3647               result = get_aarch64_segment_type (p_type);
3648               break;
3649             case EM_ARM:
3650               result = get_arm_segment_type (p_type);
3651               break;
3652             case EM_MIPS:
3653             case EM_MIPS_RS3_LE:
3654               result = get_mips_segment_type (p_type);
3655               break;
3656             case EM_PARISC:
3657               result = get_parisc_segment_type (p_type);
3658               break;
3659             case EM_IA_64:
3660               result = get_ia64_segment_type (p_type);
3661               break;
3662             case EM_TI_C6000:
3663               result = get_tic6x_segment_type (p_type);
3664               break;
3665             default:
3666               result = NULL;
3667               break;
3668             }
3669
3670           if (result != NULL)
3671             return result;
3672
3673           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3674         }
3675       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3676         {
3677           const char * result;
3678
3679           switch (elf_header.e_machine)
3680             {
3681             case EM_PARISC:
3682               result = get_parisc_segment_type (p_type);
3683               break;
3684             case EM_IA_64:
3685               result = get_ia64_segment_type (p_type);
3686               break;
3687             default:
3688               result = NULL;
3689               break;
3690             }
3691
3692           if (result != NULL)
3693             return result;
3694
3695           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3696         }
3697       else
3698         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3699
3700       return buff;
3701     }
3702 }
3703
3704 static const char *
3705 get_mips_section_type_name (unsigned int sh_type)
3706 {
3707   switch (sh_type)
3708     {
3709     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3710     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3711     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3712     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3713     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3714     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3715     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3716     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3717     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3718     case SHT_MIPS_RELD:          return "MIPS_RELD";
3719     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3720     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3721     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3722     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3723     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3724     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3725     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3726     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3727     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3728     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3729     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3730     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3731     case SHT_MIPS_LINE:          return "MIPS_LINE";
3732     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3733     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3734     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3735     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3736     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3737     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3738     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3739     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3740     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3741     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3742     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3743     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3744     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3745     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3746     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3747     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3748     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3749     default:
3750       break;
3751     }
3752   return NULL;
3753 }
3754
3755 static const char *
3756 get_parisc_section_type_name (unsigned int sh_type)
3757 {
3758   switch (sh_type)
3759     {
3760     case SHT_PARISC_EXT:        return "PARISC_EXT";
3761     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3762     case SHT_PARISC_DOC:        return "PARISC_DOC";
3763     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3764     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3765     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3766     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3767     default:
3768       break;
3769     }
3770   return NULL;
3771 }
3772
3773 static const char *
3774 get_ia64_section_type_name (unsigned int sh_type)
3775 {
3776   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3777   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3778     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3779
3780   switch (sh_type)
3781     {
3782     case SHT_IA_64_EXT:                return "IA_64_EXT";
3783     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3784     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3785     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3786     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3787     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3788     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3789     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3790     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3791     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3792     default:
3793       break;
3794     }
3795   return NULL;
3796 }
3797
3798 static const char *
3799 get_x86_64_section_type_name (unsigned int sh_type)
3800 {
3801   switch (sh_type)
3802     {
3803     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3804     default:
3805       break;
3806     }
3807   return NULL;
3808 }
3809
3810 static const char *
3811 get_aarch64_section_type_name (unsigned int sh_type)
3812 {
3813   switch (sh_type)
3814     {
3815     case SHT_AARCH64_ATTRIBUTES:
3816       return "AARCH64_ATTRIBUTES";
3817     default:
3818       break;
3819     }
3820   return NULL;
3821 }
3822
3823 static const char *
3824 get_arm_section_type_name (unsigned int sh_type)
3825 {
3826   switch (sh_type)
3827     {
3828     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3829     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3830     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3831     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3832     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3833     default:
3834       break;
3835     }
3836   return NULL;
3837 }
3838
3839 static const char *
3840 get_tic6x_section_type_name (unsigned int sh_type)
3841 {
3842   switch (sh_type)
3843     {
3844     case SHT_C6000_UNWIND:
3845       return "C6000_UNWIND";
3846     case SHT_C6000_PREEMPTMAP:
3847       return "C6000_PREEMPTMAP";
3848     case SHT_C6000_ATTRIBUTES:
3849       return "C6000_ATTRIBUTES";
3850     case SHT_TI_ICODE:
3851       return "TI_ICODE";
3852     case SHT_TI_XREF:
3853       return "TI_XREF";
3854     case SHT_TI_HANDLER:
3855       return "TI_HANDLER";
3856     case SHT_TI_INITINFO:
3857       return "TI_INITINFO";
3858     case SHT_TI_PHATTRS:
3859       return "TI_PHATTRS";
3860     default:
3861       break;
3862     }
3863   return NULL;
3864 }
3865
3866 static const char *
3867 get_msp430x_section_type_name (unsigned int sh_type)
3868 {
3869   switch (sh_type)
3870     {
3871     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3872     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3873     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3874     default: return NULL;
3875     }
3876 }
3877
3878 static const char *
3879 get_v850_section_type_name (unsigned int sh_type)
3880 {
3881   switch (sh_type)
3882     {
3883     case SHT_V850_SCOMMON: return "V850 Small Common";
3884     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3885     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3886     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3887     case SHT_RENESAS_INFO: return "RENESAS INFO";
3888     default: return NULL;
3889     }
3890 }
3891
3892 static const char *
3893 get_section_type_name (unsigned int sh_type)
3894 {
3895   static char buff[32];
3896   const char * result;
3897
3898   switch (sh_type)
3899     {
3900     case SHT_NULL:              return "NULL";
3901     case SHT_PROGBITS:          return "PROGBITS";
3902     case SHT_SYMTAB:            return "SYMTAB";
3903     case SHT_STRTAB:            return "STRTAB";
3904     case SHT_RELA:              return "RELA";
3905     case SHT_HASH:              return "HASH";
3906     case SHT_DYNAMIC:           return "DYNAMIC";
3907     case SHT_NOTE:              return "NOTE";
3908     case SHT_NOBITS:            return "NOBITS";
3909     case SHT_REL:               return "REL";
3910     case SHT_SHLIB:             return "SHLIB";
3911     case SHT_DYNSYM:            return "DYNSYM";
3912     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3913     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3914     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3915     case SHT_GNU_HASH:          return "GNU_HASH";
3916     case SHT_GROUP:             return "GROUP";
3917     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3918     case SHT_GNU_verdef:        return "VERDEF";
3919     case SHT_GNU_verneed:       return "VERNEED";
3920     case SHT_GNU_versym:        return "VERSYM";
3921     case 0x6ffffff0:            return "VERSYM";
3922     case 0x6ffffffc:            return "VERDEF";
3923     case 0x7ffffffd:            return "AUXILIARY";
3924     case 0x7fffffff:            return "FILTER";
3925     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3926
3927     default:
3928       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3929         {
3930           switch (elf_header.e_machine)
3931             {
3932             case EM_MIPS:
3933             case EM_MIPS_RS3_LE:
3934               result = get_mips_section_type_name (sh_type);
3935               break;
3936             case EM_PARISC:
3937               result = get_parisc_section_type_name (sh_type);
3938               break;
3939             case EM_IA_64:
3940               result = get_ia64_section_type_name (sh_type);
3941               break;
3942             case EM_X86_64:
3943             case EM_L1OM:
3944             case EM_K1OM:
3945               result = get_x86_64_section_type_name (sh_type);
3946               break;
3947             case EM_AARCH64:
3948               result = get_aarch64_section_type_name (sh_type);
3949               break;
3950             case EM_ARM:
3951               result = get_arm_section_type_name (sh_type);
3952               break;
3953             case EM_TI_C6000:
3954               result = get_tic6x_section_type_name (sh_type);
3955               break;
3956             case EM_MSP430:
3957               result = get_msp430x_section_type_name (sh_type);
3958               break;
3959             case EM_V800:
3960             case EM_V850:
3961             case EM_CYGNUS_V850:
3962               result = get_v850_section_type_name (sh_type);
3963               break;
3964             default:
3965               result = NULL;
3966               break;
3967             }
3968
3969           if (result != NULL)
3970             return result;
3971
3972           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
3973         }
3974       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3975         {
3976           switch (elf_header.e_machine)
3977             {
3978             case EM_IA_64:
3979               result = get_ia64_section_type_name (sh_type);
3980               break;
3981             default:
3982               result = NULL;
3983               break;
3984             }
3985
3986           if (result != NULL)
3987             return result;
3988
3989           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
3990         }
3991       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3992         {
3993           switch (elf_header.e_machine)
3994             {
3995             case EM_V800:
3996             case EM_V850:
3997             case EM_CYGNUS_V850:
3998               result = get_v850_section_type_name (sh_type);
3999             default:
4000               result = NULL;
4001               break;
4002             }
4003
4004           if (result != NULL)
4005             return result;
4006
4007           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4008         }
4009       else
4010         /* This message is probably going to be displayed in a 15
4011            character wide field, so put the hex value first.  */
4012         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4013
4014       return buff;
4015     }
4016 }
4017
4018 #define OPTION_DEBUG_DUMP       512
4019 #define OPTION_DYN_SYMS         513
4020 #define OPTION_DWARF_DEPTH      514
4021 #define OPTION_DWARF_START      515
4022 #define OPTION_DWARF_CHECK      516
4023
4024 static struct option options[] =
4025 {
4026   {"all",              no_argument, 0, 'a'},
4027   {"file-header",      no_argument, 0, 'h'},
4028   {"program-headers",  no_argument, 0, 'l'},
4029   {"headers",          no_argument, 0, 'e'},
4030   {"histogram",        no_argument, 0, 'I'},
4031   {"segments",         no_argument, 0, 'l'},
4032   {"sections",         no_argument, 0, 'S'},
4033   {"section-headers",  no_argument, 0, 'S'},
4034   {"section-groups",   no_argument, 0, 'g'},
4035   {"section-details",  no_argument, 0, 't'},
4036   {"full-section-name",no_argument, 0, 'N'},
4037   {"symbols",          no_argument, 0, 's'},
4038   {"syms",             no_argument, 0, 's'},
4039   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4040   {"relocs",           no_argument, 0, 'r'},
4041   {"notes",            no_argument, 0, 'n'},
4042   {"dynamic",          no_argument, 0, 'd'},
4043   {"arch-specific",    no_argument, 0, 'A'},
4044   {"version-info",     no_argument, 0, 'V'},
4045   {"use-dynamic",      no_argument, 0, 'D'},
4046   {"unwind",           no_argument, 0, 'u'},
4047   {"archive-index",    no_argument, 0, 'c'},
4048   {"hex-dump",         required_argument, 0, 'x'},
4049   {"relocated-dump",   required_argument, 0, 'R'},
4050   {"string-dump",      required_argument, 0, 'p'},
4051   {"decompress",       no_argument, 0, 'z'},
4052 #ifdef SUPPORT_DISASSEMBLY
4053   {"instruction-dump", required_argument, 0, 'i'},
4054 #endif
4055   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4056
4057   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4058   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4059   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4060
4061   {"version",          no_argument, 0, 'v'},
4062   {"wide",             no_argument, 0, 'W'},
4063   {"help",             no_argument, 0, 'H'},
4064   {0,                  no_argument, 0, 0}
4065 };
4066
4067 static void
4068 usage (FILE * stream)
4069 {
4070   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4071   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4072   fprintf (stream, _(" Options are:\n\
4073   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4074   -h --file-header       Display the ELF file header\n\
4075   -l --program-headers   Display the program headers\n\
4076      --segments          An alias for --program-headers\n\
4077   -S --section-headers   Display the sections' header\n\
4078      --sections          An alias for --section-headers\n\
4079   -g --section-groups    Display the section groups\n\
4080   -t --section-details   Display the section details\n\
4081   -e --headers           Equivalent to: -h -l -S\n\
4082   -s --syms              Display the symbol table\n\
4083      --symbols           An alias for --syms\n\
4084   --dyn-syms             Display the dynamic symbol table\n\
4085   -n --notes             Display the core notes (if present)\n\
4086   -r --relocs            Display the relocations (if present)\n\
4087   -u --unwind            Display the unwind info (if present)\n\
4088   -d --dynamic           Display the dynamic section (if present)\n\
4089   -V --version-info      Display the version sections (if present)\n\
4090   -A --arch-specific     Display architecture specific information (if any)\n\
4091   -c --archive-index     Display the symbol/file index in an archive\n\
4092   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4093   -x --hex-dump=<number|name>\n\
4094                          Dump the contents of section <number|name> as bytes\n\
4095   -p --string-dump=<number|name>\n\
4096                          Dump the contents of section <number|name> as strings\n\
4097   -R --relocated-dump=<number|name>\n\
4098                          Dump the contents of section <number|name> as relocated bytes\n\
4099   -z --decompress        Decompress section before dumping it\n\
4100   -w[lLiaprmfFsoRt] or\n\
4101   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4102                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4103                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4104                =addr,=cu_index]\n\
4105                          Display the contents of DWARF2 debug sections\n"));
4106   fprintf (stream, _("\
4107   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4108   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4109                          or deeper\n"));
4110 #ifdef SUPPORT_DISASSEMBLY
4111   fprintf (stream, _("\
4112   -i --instruction-dump=<number|name>\n\
4113                          Disassemble the contents of section <number|name>\n"));
4114 #endif
4115   fprintf (stream, _("\
4116   -I --histogram         Display histogram of bucket list lengths\n\
4117   -W --wide              Allow output width to exceed 80 characters\n\
4118   @<file>                Read options from <file>\n\
4119   -H --help              Display this information\n\
4120   -v --version           Display the version number of readelf\n"));
4121
4122   if (REPORT_BUGS_TO[0] && stream == stdout)
4123     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4124
4125   exit (stream == stdout ? 0 : 1);
4126 }
4127
4128 /* Record the fact that the user wants the contents of section number
4129    SECTION to be displayed using the method(s) encoded as flags bits
4130    in TYPE.  Note, TYPE can be zero if we are creating the array for
4131    the first time.  */
4132
4133 static void
4134 request_dump_bynumber (unsigned int section, dump_type type)
4135 {
4136   if (section >= num_dump_sects)
4137     {
4138       dump_type * new_dump_sects;
4139
4140       new_dump_sects = (dump_type *) calloc (section + 1,
4141                                              sizeof (* dump_sects));
4142
4143       if (new_dump_sects == NULL)
4144         error (_("Out of memory allocating dump request table.\n"));
4145       else
4146         {
4147           /* Copy current flag settings.  */
4148           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4149
4150           free (dump_sects);
4151
4152           dump_sects = new_dump_sects;
4153           num_dump_sects = section + 1;
4154         }
4155     }
4156
4157   if (dump_sects)
4158     dump_sects[section] |= type;
4159
4160   return;
4161 }
4162
4163 /* Request a dump by section name.  */
4164
4165 static void
4166 request_dump_byname (const char * section, dump_type type)
4167 {
4168   struct dump_list_entry * new_request;
4169
4170   new_request = (struct dump_list_entry *)
4171       malloc (sizeof (struct dump_list_entry));
4172   if (!new_request)
4173     error (_("Out of memory allocating dump request table.\n"));
4174
4175   new_request->name = strdup (section);
4176   if (!new_request->name)
4177     error (_("Out of memory allocating dump request table.\n"));
4178
4179   new_request->type = type;
4180
4181   new_request->next = dump_sects_byname;
4182   dump_sects_byname = new_request;
4183 }
4184
4185 static inline void
4186 request_dump (dump_type type)
4187 {
4188   int section;
4189   char * cp;
4190
4191   do_dump++;
4192   section = strtoul (optarg, & cp, 0);
4193
4194   if (! *cp && section >= 0)
4195     request_dump_bynumber (section, type);
4196   else
4197     request_dump_byname (optarg, type);
4198 }
4199
4200
4201 static void
4202 parse_args (int argc, char ** argv)
4203 {
4204   int c;
4205
4206   if (argc < 2)
4207     usage (stderr);
4208
4209   while ((c = getopt_long
4210           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4211     {
4212       switch (c)
4213         {
4214         case 0:
4215           /* Long options.  */
4216           break;
4217         case 'H':
4218           usage (stdout);
4219           break;
4220
4221         case 'a':
4222           do_syms++;
4223           do_reloc++;
4224           do_unwind++;
4225           do_dynamic++;
4226           do_header++;
4227           do_sections++;
4228           do_section_groups++;
4229           do_segments++;
4230           do_version++;
4231           do_histogram++;
4232           do_arch++;
4233           do_notes++;
4234           break;
4235         case 'g':
4236           do_section_groups++;
4237           break;
4238         case 't':
4239         case 'N':
4240           do_sections++;
4241           do_section_details++;
4242           break;
4243         case 'e':
4244           do_header++;
4245           do_sections++;
4246           do_segments++;
4247           break;
4248         case 'A':
4249           do_arch++;
4250           break;
4251         case 'D':
4252           do_using_dynamic++;
4253           break;
4254         case 'r':
4255           do_reloc++;
4256           break;
4257         case 'u':
4258           do_unwind++;
4259           break;
4260         case 'h':
4261           do_header++;
4262           break;
4263         case 'l':
4264           do_segments++;
4265           break;
4266         case 's':
4267           do_syms++;
4268           break;
4269         case 'S':
4270           do_sections++;
4271           break;
4272         case 'd':
4273           do_dynamic++;
4274           break;
4275         case 'I':
4276           do_histogram++;
4277           break;
4278         case 'n':
4279           do_notes++;
4280           break;
4281         case 'c':
4282           do_archive_index++;
4283           break;
4284         case 'x':
4285           request_dump (HEX_DUMP);
4286           break;
4287         case 'p':
4288           request_dump (STRING_DUMP);
4289           break;
4290         case 'R':
4291           request_dump (RELOC_DUMP);
4292           break;
4293         case 'z':
4294           decompress_dumps++;
4295           break;
4296         case 'w':
4297           do_dump++;
4298           if (optarg == 0)
4299             {
4300               do_debugging = 1;
4301               dwarf_select_sections_all ();
4302             }
4303           else
4304             {
4305               do_debugging = 0;
4306               dwarf_select_sections_by_letters (optarg);
4307             }
4308           break;
4309         case OPTION_DEBUG_DUMP:
4310           do_dump++;
4311           if (optarg == 0)
4312             do_debugging = 1;
4313           else
4314             {
4315               do_debugging = 0;
4316               dwarf_select_sections_by_names (optarg);
4317             }
4318           break;
4319         case OPTION_DWARF_DEPTH:
4320           {
4321             char *cp;
4322
4323             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4324           }
4325           break;
4326         case OPTION_DWARF_START:
4327           {
4328             char *cp;
4329
4330             dwarf_start_die = strtoul (optarg, & cp, 0);
4331           }
4332           break;
4333         case OPTION_DWARF_CHECK:
4334           dwarf_check = 1;
4335           break;
4336         case OPTION_DYN_SYMS:
4337           do_dyn_syms++;
4338           break;
4339 #ifdef SUPPORT_DISASSEMBLY
4340         case 'i':
4341           request_dump (DISASS_DUMP);
4342           break;
4343 #endif
4344         case 'v':
4345           print_version (program_name);
4346           break;
4347         case 'V':
4348           do_version++;
4349           break;
4350         case 'W':
4351           do_wide++;
4352           break;
4353         default:
4354           /* xgettext:c-format */
4355           error (_("Invalid option '-%c'\n"), c);
4356           /* Drop through.  */
4357         case '?':
4358           usage (stderr);
4359         }
4360     }
4361
4362   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4363       && !do_segments && !do_header && !do_dump && !do_version
4364       && !do_histogram && !do_debugging && !do_arch && !do_notes
4365       && !do_section_groups && !do_archive_index
4366       && !do_dyn_syms)
4367     usage (stderr);
4368 }
4369
4370 static const char *
4371 get_elf_class (unsigned int elf_class)
4372 {
4373   static char buff[32];
4374
4375   switch (elf_class)
4376     {
4377     case ELFCLASSNONE: return _("none");
4378     case ELFCLASS32:   return "ELF32";
4379     case ELFCLASS64:   return "ELF64";
4380     default:
4381       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4382       return buff;
4383     }
4384 }
4385
4386 static const char *
4387 get_data_encoding (unsigned int encoding)
4388 {
4389   static char buff[32];
4390
4391   switch (encoding)
4392     {
4393     case ELFDATANONE: return _("none");
4394     case ELFDATA2LSB: return _("2's complement, little endian");
4395     case ELFDATA2MSB: return _("2's complement, big endian");
4396     default:
4397       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4398       return buff;
4399     }
4400 }
4401
4402 /* Decode the data held in 'elf_header'.  */
4403
4404 static int
4405 process_file_header (void)
4406 {
4407   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4408       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4409       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4410       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4411     {
4412       error
4413         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4414       return 0;
4415     }
4416
4417   init_dwarf_regnames (elf_header.e_machine);
4418
4419   if (do_header)
4420     {
4421       int i;
4422
4423       printf (_("ELF Header:\n"));
4424       printf (_("  Magic:   "));
4425       for (i = 0; i < EI_NIDENT; i++)
4426         printf ("%2.2x ", elf_header.e_ident[i]);
4427       printf ("\n");
4428       printf (_("  Class:                             %s\n"),
4429               get_elf_class (elf_header.e_ident[EI_CLASS]));
4430       printf (_("  Data:                              %s\n"),
4431               get_data_encoding (elf_header.e_ident[EI_DATA]));
4432       printf (_("  Version:                           %d %s\n"),
4433               elf_header.e_ident[EI_VERSION],
4434               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4435                ? "(current)"
4436                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4437                   ? _("<unknown: %lx>")
4438                   : "")));
4439       printf (_("  OS/ABI:                            %s\n"),
4440               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4441       printf (_("  ABI Version:                       %d\n"),
4442               elf_header.e_ident[EI_ABIVERSION]);
4443       printf (_("  Type:                              %s\n"),
4444               get_file_type (elf_header.e_type));
4445       printf (_("  Machine:                           %s\n"),
4446               get_machine_name (elf_header.e_machine));
4447       printf (_("  Version:                           0x%lx\n"),
4448               (unsigned long) elf_header.e_version);
4449
4450       printf (_("  Entry point address:               "));
4451       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4452       printf (_("\n  Start of program headers:          "));
4453       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4454       printf (_(" (bytes into file)\n  Start of section headers:          "));
4455       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4456       printf (_(" (bytes into file)\n"));
4457
4458       printf (_("  Flags:                             0x%lx%s\n"),
4459               (unsigned long) elf_header.e_flags,
4460               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4461       printf (_("  Size of this header:               %ld (bytes)\n"),
4462               (long) elf_header.e_ehsize);
4463       printf (_("  Size of program headers:           %ld (bytes)\n"),
4464               (long) elf_header.e_phentsize);
4465       printf (_("  Number of program headers:         %ld"),
4466               (long) elf_header.e_phnum);
4467       if (section_headers != NULL
4468           && elf_header.e_phnum == PN_XNUM
4469           && section_headers[0].sh_info != 0)
4470         printf (" (%ld)", (long) section_headers[0].sh_info);
4471       putc ('\n', stdout);
4472       printf (_("  Size of section headers:           %ld (bytes)\n"),
4473               (long) elf_header.e_shentsize);
4474       printf (_("  Number of section headers:         %ld"),
4475               (long) elf_header.e_shnum);
4476       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4477         printf (" (%ld)", (long) section_headers[0].sh_size);
4478       putc ('\n', stdout);
4479       printf (_("  Section header string table index: %ld"),
4480               (long) elf_header.e_shstrndx);
4481       if (section_headers != NULL
4482           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4483         printf (" (%u)", section_headers[0].sh_link);
4484       else if (elf_header.e_shstrndx != SHN_UNDEF
4485                && elf_header.e_shstrndx >= elf_header.e_shnum)
4486         printf (_(" <corrupt: out of range>"));
4487       putc ('\n', stdout);
4488     }
4489
4490   if (section_headers != NULL)
4491     {
4492       if (elf_header.e_phnum == PN_XNUM
4493           && section_headers[0].sh_info != 0)
4494         elf_header.e_phnum = section_headers[0].sh_info;
4495       if (elf_header.e_shnum == SHN_UNDEF)
4496         elf_header.e_shnum = section_headers[0].sh_size;
4497       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4498         elf_header.e_shstrndx = section_headers[0].sh_link;
4499       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4500         elf_header.e_shstrndx = SHN_UNDEF;
4501       free (section_headers);
4502       section_headers = NULL;
4503     }
4504
4505   return 1;
4506 }
4507
4508 static bfd_boolean
4509 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4510 {
4511   Elf32_External_Phdr * phdrs;
4512   Elf32_External_Phdr * external;
4513   Elf_Internal_Phdr *   internal;
4514   unsigned int i;
4515   unsigned int size = elf_header.e_phentsize;
4516   unsigned int num  = elf_header.e_phnum;
4517
4518   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4519   if (size == 0 || num == 0)
4520     return FALSE;
4521   if (size < sizeof * phdrs)
4522     {
4523       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4524       return FALSE;
4525     }
4526   if (size > sizeof * phdrs)
4527     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4528
4529   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4530                                             size, num, _("program headers"));
4531   if (phdrs == NULL)
4532     return FALSE;
4533
4534   for (i = 0, internal = pheaders, external = phdrs;
4535        i < elf_header.e_phnum;
4536        i++, internal++, external++)
4537     {
4538       internal->p_type   = BYTE_GET (external->p_type);
4539       internal->p_offset = BYTE_GET (external->p_offset);
4540       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4541       internal->p_paddr  = BYTE_GET (external->p_paddr);
4542       internal->p_filesz = BYTE_GET (external->p_filesz);
4543       internal->p_memsz  = BYTE_GET (external->p_memsz);
4544       internal->p_flags  = BYTE_GET (external->p_flags);
4545       internal->p_align  = BYTE_GET (external->p_align);
4546     }
4547
4548   free (phdrs);
4549   return TRUE;
4550 }
4551
4552 static bfd_boolean
4553 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4554 {
4555   Elf64_External_Phdr * phdrs;
4556   Elf64_External_Phdr * external;
4557   Elf_Internal_Phdr *   internal;
4558   unsigned int i;
4559   unsigned int size = elf_header.e_phentsize;
4560   unsigned int num  = elf_header.e_phnum;
4561
4562   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4563   if (size == 0 || num == 0)
4564     return FALSE;
4565   if (size < sizeof * phdrs)
4566     {
4567       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4568       return FALSE;
4569     }
4570   if (size > sizeof * phdrs)
4571     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4572
4573   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4574                                             size, num, _("program headers"));
4575   if (!phdrs)
4576     return FALSE;
4577
4578   for (i = 0, internal = pheaders, external = phdrs;
4579        i < elf_header.e_phnum;
4580        i++, internal++, external++)
4581     {
4582       internal->p_type   = BYTE_GET (external->p_type);
4583       internal->p_flags  = BYTE_GET (external->p_flags);
4584       internal->p_offset = BYTE_GET (external->p_offset);
4585       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4586       internal->p_paddr  = BYTE_GET (external->p_paddr);
4587       internal->p_filesz = BYTE_GET (external->p_filesz);
4588       internal->p_memsz  = BYTE_GET (external->p_memsz);
4589       internal->p_align  = BYTE_GET (external->p_align);
4590     }
4591
4592   free (phdrs);
4593   return TRUE;
4594 }
4595
4596 /* Returns 1 if the program headers were read into `program_headers'.  */
4597
4598 static int
4599 get_program_headers (FILE * file)
4600 {
4601   Elf_Internal_Phdr * phdrs;
4602
4603   /* Check cache of prior read.  */
4604   if (program_headers != NULL)
4605     return 1;
4606
4607   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4608                                          sizeof (Elf_Internal_Phdr));
4609
4610   if (phdrs == NULL)
4611     {
4612       error (_("Out of memory reading %u program headers\n"),
4613              elf_header.e_phnum);
4614       return 0;
4615     }
4616
4617   if (is_32bit_elf
4618       ? get_32bit_program_headers (file, phdrs)
4619       : get_64bit_program_headers (file, phdrs))
4620     {
4621       program_headers = phdrs;
4622       return 1;
4623     }
4624
4625   free (phdrs);
4626   return 0;
4627 }
4628
4629 /* Returns 1 if the program headers were loaded.  */
4630
4631 static int
4632 process_program_headers (FILE * file)
4633 {
4634   Elf_Internal_Phdr * segment;
4635   unsigned int i;
4636
4637   if (elf_header.e_phnum == 0)
4638     {
4639       /* PR binutils/12467.  */
4640       if (elf_header.e_phoff != 0)
4641         warn (_("possibly corrupt ELF header - it has a non-zero program"
4642                 " header offset, but no program headers\n"));
4643       else if (do_segments)
4644         printf (_("\nThere are no program headers in this file.\n"));
4645       return 0;
4646     }
4647
4648   if (do_segments && !do_header)
4649     {
4650       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4651       printf (_("Entry point "));
4652       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4653       printf (_("\nThere are %d program headers, starting at offset "),
4654               elf_header.e_phnum);
4655       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4656       printf ("\n");
4657     }
4658
4659   if (! get_program_headers (file))
4660       return 0;
4661
4662   if (do_segments)
4663     {
4664       if (elf_header.e_phnum > 1)
4665         printf (_("\nProgram Headers:\n"));
4666       else
4667         printf (_("\nProgram Headers:\n"));
4668
4669       if (is_32bit_elf)
4670         printf
4671           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4672       else if (do_wide)
4673         printf
4674           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4675       else
4676         {
4677           printf
4678             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4679           printf
4680             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4681         }
4682     }
4683
4684   dynamic_addr = 0;
4685   dynamic_size = 0;
4686
4687   for (i = 0, segment = program_headers;
4688        i < elf_header.e_phnum;
4689        i++, segment++)
4690     {
4691       if (do_segments)
4692         {
4693           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4694
4695           if (is_32bit_elf)
4696             {
4697               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4698               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4699               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4700               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4701               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4702               printf ("%c%c%c ",
4703                       (segment->p_flags & PF_R ? 'R' : ' '),
4704                       (segment->p_flags & PF_W ? 'W' : ' '),
4705                       (segment->p_flags & PF_X ? 'E' : ' '));
4706               printf ("%#lx", (unsigned long) segment->p_align);
4707             }
4708           else if (do_wide)
4709             {
4710               if ((unsigned long) segment->p_offset == segment->p_offset)
4711                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4712               else
4713                 {
4714                   print_vma (segment->p_offset, FULL_HEX);
4715                   putchar (' ');
4716                 }
4717
4718               print_vma (segment->p_vaddr, FULL_HEX);
4719               putchar (' ');
4720               print_vma (segment->p_paddr, FULL_HEX);
4721               putchar (' ');
4722
4723               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4724                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4725               else
4726                 {
4727                   print_vma (segment->p_filesz, FULL_HEX);
4728                   putchar (' ');
4729                 }
4730
4731               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4732                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4733               else
4734                 {
4735                   print_vma (segment->p_memsz, FULL_HEX);
4736                 }
4737
4738               printf (" %c%c%c ",
4739                       (segment->p_flags & PF_R ? 'R' : ' '),
4740                       (segment->p_flags & PF_W ? 'W' : ' '),
4741                       (segment->p_flags & PF_X ? 'E' : ' '));
4742
4743               if ((unsigned long) segment->p_align == segment->p_align)
4744                 printf ("%#lx", (unsigned long) segment->p_align);
4745               else
4746                 {
4747                   print_vma (segment->p_align, PREFIX_HEX);
4748                 }
4749             }
4750           else
4751             {
4752               print_vma (segment->p_offset, FULL_HEX);
4753               putchar (' ');
4754               print_vma (segment->p_vaddr, FULL_HEX);
4755               putchar (' ');
4756               print_vma (segment->p_paddr, FULL_HEX);
4757               printf ("\n                 ");
4758               print_vma (segment->p_filesz, FULL_HEX);
4759               putchar (' ');
4760               print_vma (segment->p_memsz, FULL_HEX);
4761               printf ("  %c%c%c    ",
4762                       (segment->p_flags & PF_R ? 'R' : ' '),
4763                       (segment->p_flags & PF_W ? 'W' : ' '),
4764                       (segment->p_flags & PF_X ? 'E' : ' '));
4765               print_vma (segment->p_align, HEX);
4766             }
4767         }
4768
4769       if (do_segments)
4770         putc ('\n', stdout);
4771
4772       switch (segment->p_type)
4773         {
4774         case PT_DYNAMIC:
4775           if (dynamic_addr)
4776             error (_("more than one dynamic segment\n"));
4777
4778           /* By default, assume that the .dynamic section is the first
4779              section in the DYNAMIC segment.  */
4780           dynamic_addr = segment->p_offset;
4781           dynamic_size = segment->p_filesz;
4782           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4783           if (dynamic_addr + dynamic_size >= current_file_size)
4784             {
4785               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4786               dynamic_addr = dynamic_size = 0;
4787             }
4788
4789           /* Try to locate the .dynamic section. If there is
4790              a section header table, we can easily locate it.  */
4791           if (section_headers != NULL)
4792             {
4793               Elf_Internal_Shdr * sec;
4794
4795               sec = find_section (".dynamic");
4796               if (sec == NULL || sec->sh_size == 0)
4797                 {
4798                   /* A corresponding .dynamic section is expected, but on
4799                      IA-64/OpenVMS it is OK for it to be missing.  */
4800                   if (!is_ia64_vms ())
4801                     error (_("no .dynamic section in the dynamic segment\n"));
4802                   break;
4803                 }
4804
4805               if (sec->sh_type == SHT_NOBITS)
4806                 {
4807                   dynamic_size = 0;
4808                   break;
4809                 }
4810
4811               dynamic_addr = sec->sh_offset;
4812               dynamic_size = sec->sh_size;
4813
4814               if (dynamic_addr < segment->p_offset
4815                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4816                 warn (_("the .dynamic section is not contained"
4817                         " within the dynamic segment\n"));
4818               else if (dynamic_addr > segment->p_offset)
4819                 warn (_("the .dynamic section is not the first section"
4820                         " in the dynamic segment.\n"));
4821             }
4822           break;
4823
4824         case PT_INTERP:
4825           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4826                      SEEK_SET))
4827             error (_("Unable to find program interpreter name\n"));
4828           else
4829             {
4830               char fmt [32];
4831               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4832
4833               if (ret >= (int) sizeof (fmt) || ret < 0)
4834                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4835
4836               program_interpreter[0] = 0;
4837               if (fscanf (file, fmt, program_interpreter) <= 0)
4838                 error (_("Unable to read program interpreter name\n"));
4839
4840               if (do_segments)
4841                 printf (_("      [Requesting program interpreter: %s]\n"),
4842                     program_interpreter);
4843             }
4844           break;
4845         }
4846     }
4847
4848   if (do_segments && section_headers != NULL && string_table != NULL)
4849     {
4850       printf (_("\n Section to Segment mapping:\n"));
4851       printf (_("  Segment Sections...\n"));
4852
4853       for (i = 0; i < elf_header.e_phnum; i++)
4854         {
4855           unsigned int j;
4856           Elf_Internal_Shdr * section;
4857
4858           segment = program_headers + i;
4859           section = section_headers + 1;
4860
4861           printf ("   %2.2d     ", i);
4862
4863           for (j = 1; j < elf_header.e_shnum; j++, section++)
4864             {
4865               if (!ELF_TBSS_SPECIAL (section, segment)
4866                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4867                 printf ("%s ", printable_section_name (section));
4868             }
4869
4870           putc ('\n',stdout);
4871         }
4872     }
4873
4874   return 1;
4875 }
4876
4877
4878 /* Find the file offset corresponding to VMA by using the program headers.  */
4879
4880 static long
4881 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4882 {
4883   Elf_Internal_Phdr * seg;
4884
4885   if (! get_program_headers (file))
4886     {
4887       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4888       return (long) vma;
4889     }
4890
4891   for (seg = program_headers;
4892        seg < program_headers + elf_header.e_phnum;
4893        ++seg)
4894     {
4895       if (seg->p_type != PT_LOAD)
4896         continue;
4897
4898       if (vma >= (seg->p_vaddr & -seg->p_align)
4899           && vma + size <= seg->p_vaddr + seg->p_filesz)
4900         return vma - seg->p_vaddr + seg->p_offset;
4901     }
4902
4903   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4904         (unsigned long) vma);
4905   return (long) vma;
4906 }
4907
4908
4909 /* Allocate memory and load the sections headers into the global pointer
4910    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4911    generate any error messages if the load fails.  */
4912
4913 static bfd_boolean
4914 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4915 {
4916   Elf32_External_Shdr * shdrs;
4917   Elf_Internal_Shdr *   internal;
4918   unsigned int i;
4919   unsigned int size = elf_header.e_shentsize;
4920   unsigned int num = probe ? 1 : elf_header.e_shnum;
4921
4922   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4923   if (size == 0 || num == 0)
4924     return FALSE;
4925   if (size < sizeof * shdrs)
4926     {
4927       if (! probe)
4928         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4929       return FALSE;
4930     }
4931   if (!probe && size > sizeof * shdrs)
4932     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4933
4934   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4935                                             size, num,
4936                                             probe ? NULL : _("section headers"));
4937   if (shdrs == NULL)
4938     return FALSE;
4939
4940   if (section_headers != NULL)
4941     free (section_headers);
4942   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4943                                                    sizeof (Elf_Internal_Shdr));
4944   if (section_headers == NULL)
4945     {
4946       if (!probe)
4947         error (_("Out of memory reading %u section headers\n"), num);
4948       return FALSE;
4949     }
4950
4951   for (i = 0, internal = section_headers;
4952        i < num;
4953        i++, internal++)
4954     {
4955       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4956       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4957       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4958       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4959       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4960       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4961       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4962       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4963       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4964       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4965     }
4966
4967   free (shdrs);
4968   return TRUE;
4969 }
4970
4971 static bfd_boolean
4972 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4973 {
4974   Elf64_External_Shdr * shdrs;
4975   Elf_Internal_Shdr *   internal;
4976   unsigned int i;
4977   unsigned int size = elf_header.e_shentsize;
4978   unsigned int num = probe ? 1 : elf_header.e_shnum;
4979
4980   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4981   if (size == 0 || num == 0)
4982     return FALSE;
4983   if (size < sizeof * shdrs)
4984     {
4985       if (! probe)
4986         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4987       return FALSE;
4988     }
4989   if (! probe && size > sizeof * shdrs)
4990     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4991
4992   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4993                                             size, num,
4994                                             probe ? NULL : _("section headers"));
4995   if (shdrs == NULL)
4996     return FALSE;
4997
4998   if (section_headers != NULL)
4999     free (section_headers);
5000   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5001                                                    sizeof (Elf_Internal_Shdr));
5002   if (section_headers == NULL)
5003     {
5004       if (! probe)
5005         error (_("Out of memory reading %u section headers\n"), num);
5006       return FALSE;
5007     }
5008
5009   for (i = 0, internal = section_headers;
5010        i < num;
5011        i++, internal++)
5012     {
5013       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5014       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5015       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5016       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5017       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5018       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5019       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5020       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5021       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5022       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5023     }
5024
5025   free (shdrs);
5026   return TRUE;
5027 }
5028
5029 static Elf_Internal_Sym *
5030 get_32bit_elf_symbols (FILE * file,
5031                        Elf_Internal_Shdr * section,
5032                        unsigned long * num_syms_return)
5033 {
5034   unsigned long number = 0;
5035   Elf32_External_Sym * esyms = NULL;
5036   Elf_External_Sym_Shndx * shndx = NULL;
5037   Elf_Internal_Sym * isyms = NULL;
5038   Elf_Internal_Sym * psym;
5039   unsigned int j;
5040
5041   if (section->sh_size == 0)
5042     {
5043       if (num_syms_return != NULL)
5044         * num_syms_return = 0;
5045       return NULL;
5046     }
5047
5048   /* Run some sanity checks first.  */
5049   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5050     {
5051       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5052              printable_section_name (section), (unsigned long) section->sh_entsize);
5053       goto exit_point;
5054     }
5055
5056   if (section->sh_size > current_file_size)
5057     {
5058       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5059              printable_section_name (section), (unsigned long) section->sh_size);
5060       goto exit_point;
5061     }
5062
5063   number = section->sh_size / section->sh_entsize;
5064
5065   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5066     {
5067       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5068              (unsigned long) section->sh_size,
5069              printable_section_name (section),
5070              (unsigned long) section->sh_entsize);
5071       goto exit_point;
5072     }
5073
5074   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5075                                            section->sh_size, _("symbols"));
5076   if (esyms == NULL)
5077     goto exit_point;
5078
5079   {
5080     elf_section_list * entry;
5081
5082     shndx = NULL;
5083     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5084       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5085         {
5086           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5087                                                        entry->hdr->sh_offset,
5088                                                        1, entry->hdr->sh_size,
5089                                                        _("symbol table section indicies"));
5090           if (shndx == NULL)
5091             goto exit_point;
5092           /* PR17531: file: heap-buffer-overflow */
5093           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5094             {
5095               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5096                      printable_section_name (entry->hdr),
5097                      (unsigned long) entry->hdr->sh_size,
5098                      (unsigned long) section->sh_size);
5099               goto exit_point;
5100             }
5101         }
5102   }
5103
5104   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5105
5106   if (isyms == NULL)
5107     {
5108       error (_("Out of memory reading %lu symbols\n"),
5109              (unsigned long) number);
5110       goto exit_point;
5111     }
5112
5113   for (j = 0, psym = isyms; j < number; j++, psym++)
5114     {
5115       psym->st_name  = BYTE_GET (esyms[j].st_name);
5116       psym->st_value = BYTE_GET (esyms[j].st_value);
5117       psym->st_size  = BYTE_GET (esyms[j].st_size);
5118       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5119       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5120         psym->st_shndx
5121           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5122       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5123         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5124       psym->st_info  = BYTE_GET (esyms[j].st_info);
5125       psym->st_other = BYTE_GET (esyms[j].st_other);
5126     }
5127
5128  exit_point:
5129   if (shndx != NULL)
5130     free (shndx);
5131   if (esyms != NULL)
5132     free (esyms);
5133
5134   if (num_syms_return != NULL)
5135     * num_syms_return = isyms == NULL ? 0 : number;
5136
5137   return isyms;
5138 }
5139
5140 static Elf_Internal_Sym *
5141 get_64bit_elf_symbols (FILE * file,
5142                        Elf_Internal_Shdr * section,
5143                        unsigned long * num_syms_return)
5144 {
5145   unsigned long number = 0;
5146   Elf64_External_Sym * esyms = NULL;
5147   Elf_External_Sym_Shndx * shndx = NULL;
5148   Elf_Internal_Sym * isyms = NULL;
5149   Elf_Internal_Sym * psym;
5150   unsigned int j;
5151
5152   if (section->sh_size == 0)
5153     {
5154       if (num_syms_return != NULL)
5155         * num_syms_return = 0;
5156       return NULL;
5157     }
5158
5159   /* Run some sanity checks first.  */
5160   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5161     {
5162       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5163              printable_section_name (section),
5164              (unsigned long) section->sh_entsize);
5165       goto exit_point;
5166     }
5167
5168   if (section->sh_size > current_file_size)
5169     {
5170       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5171              printable_section_name (section),
5172              (unsigned long) section->sh_size);
5173       goto exit_point;
5174     }
5175
5176   number = section->sh_size / section->sh_entsize;
5177
5178   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5179     {
5180       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5181              (unsigned long) section->sh_size,
5182              printable_section_name (section),
5183              (unsigned long) section->sh_entsize);
5184       goto exit_point;
5185     }
5186
5187   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5188                                            section->sh_size, _("symbols"));
5189   if (!esyms)
5190     goto exit_point;
5191
5192   {
5193     elf_section_list * entry;
5194
5195     shndx = NULL;
5196     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5197       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5198         {
5199           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5200                                                        entry->hdr->sh_offset,
5201                                                        1, entry->hdr->sh_size,
5202                                                        _("symbol table section indicies"));
5203           if (shndx == NULL)
5204             goto exit_point;
5205           /* PR17531: file: heap-buffer-overflow */
5206           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5207             {
5208               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5209                      printable_section_name (entry->hdr),
5210                      (unsigned long) entry->hdr->sh_size,
5211                      (unsigned long) section->sh_size);
5212               goto exit_point;
5213             }
5214         }
5215   }
5216
5217   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5218
5219   if (isyms == NULL)
5220     {
5221       error (_("Out of memory reading %lu symbols\n"),
5222              (unsigned long) number);
5223       goto exit_point;
5224     }
5225
5226   for (j = 0, psym = isyms; j < number; j++, psym++)
5227     {
5228       psym->st_name  = BYTE_GET (esyms[j].st_name);
5229       psym->st_info  = BYTE_GET (esyms[j].st_info);
5230       psym->st_other = BYTE_GET (esyms[j].st_other);
5231       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5232
5233       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5234         psym->st_shndx
5235           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5236       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5237         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5238
5239       psym->st_value = BYTE_GET (esyms[j].st_value);
5240       psym->st_size  = BYTE_GET (esyms[j].st_size);
5241     }
5242
5243  exit_point:
5244   if (shndx != NULL)
5245     free (shndx);
5246   if (esyms != NULL)
5247     free (esyms);
5248
5249   if (num_syms_return != NULL)
5250     * num_syms_return = isyms == NULL ? 0 : number;
5251
5252   return isyms;
5253 }
5254
5255 static const char *
5256 get_elf_section_flags (bfd_vma sh_flags)
5257 {
5258   static char buff[1024];
5259   char * p = buff;
5260   int field_size = is_32bit_elf ? 8 : 16;
5261   int sindex;
5262   int size = sizeof (buff) - (field_size + 4 + 1);
5263   bfd_vma os_flags = 0;
5264   bfd_vma proc_flags = 0;
5265   bfd_vma unknown_flags = 0;
5266   static const struct
5267     {
5268       const char * str;
5269       int len;
5270     }
5271   flags [] =
5272     {
5273       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5274       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5275       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5276       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5277       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5278       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5279       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5280       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5281       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5282       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5283       /* IA-64 specific.  */
5284       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5285       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5286       /* IA-64 OpenVMS specific.  */
5287       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5288       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5289       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5290       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5291       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5292       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5293       /* Generic.  */
5294       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5295       /* SPARC specific.  */
5296       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5297       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5298       /* ARM specific.  */
5299       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5300       /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5301       /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5302     };
5303
5304   if (do_section_details)
5305     {
5306       sprintf (buff, "[%*.*lx]: ",
5307                field_size, field_size, (unsigned long) sh_flags);
5308       p += field_size + 4;
5309     }
5310
5311   while (sh_flags)
5312     {
5313       bfd_vma flag;
5314
5315       flag = sh_flags & - sh_flags;
5316       sh_flags &= ~ flag;
5317
5318       if (do_section_details)
5319         {
5320           switch (flag)
5321             {
5322             case SHF_WRITE:             sindex = 0; break;
5323             case SHF_ALLOC:             sindex = 1; break;
5324             case SHF_EXECINSTR:         sindex = 2; break;
5325             case SHF_MERGE:             sindex = 3; break;
5326             case SHF_STRINGS:           sindex = 4; break;
5327             case SHF_INFO_LINK:         sindex = 5; break;
5328             case SHF_LINK_ORDER:        sindex = 6; break;
5329             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5330             case SHF_GROUP:             sindex = 8; break;
5331             case SHF_TLS:               sindex = 9; break;
5332             case SHF_EXCLUDE:           sindex = 18; break;
5333             case SHF_COMPRESSED:        sindex = 20; break;
5334
5335             default:
5336               sindex = -1;
5337               switch (elf_header.e_machine)
5338                 {
5339                 case EM_IA_64:
5340                   if (flag == SHF_IA_64_SHORT)
5341                     sindex = 10;
5342                   else if (flag == SHF_IA_64_NORECOV)
5343                     sindex = 11;
5344 #ifdef BFD64
5345                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5346                     switch (flag)
5347                       {
5348                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5349                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5350                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5351                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5352                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5353                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5354                       default:                        break;
5355                       }
5356 #endif
5357                   break;
5358
5359                 case EM_386:
5360                 case EM_IAMCU:
5361                 case EM_X86_64:
5362                 case EM_L1OM:
5363                 case EM_K1OM:
5364                 case EM_OLD_SPARCV9:
5365                 case EM_SPARC32PLUS:
5366                 case EM_SPARCV9:
5367                 case EM_SPARC:
5368                   if (flag == SHF_ORDERED)
5369                     sindex = 19;
5370                   break;
5371
5372                 case EM_ARM:
5373                   switch (flag)
5374                     {
5375                     case SHF_ENTRYSECT: sindex = 21; break;
5376                     case SHF_ARM_NOREAD: sindex = 22; break;
5377                     case SHF_COMDEF: sindex = 23; break;
5378                     default: break;
5379                     }
5380                   break;
5381
5382                 default:
5383                   break;
5384                 }
5385             }
5386
5387           if (sindex != -1)
5388             {
5389               if (p != buff + field_size + 4)
5390                 {
5391                   if (size < (10 + 2))
5392                     {
5393                       warn (_("Internal error: not enough buffer room for section flag info"));
5394                       return _("<unknown>");
5395                     }
5396                   size -= 2;
5397                   *p++ = ',';
5398                   *p++ = ' ';
5399                 }
5400
5401               size -= flags [sindex].len;
5402               p = stpcpy (p, flags [sindex].str);
5403             }
5404           else if (flag & SHF_MASKOS)
5405             os_flags |= flag;
5406           else if (flag & SHF_MASKPROC)
5407             proc_flags |= flag;
5408           else
5409             unknown_flags |= flag;
5410         }
5411       else
5412         {
5413           switch (flag)
5414             {
5415             case SHF_WRITE:             *p = 'W'; break;
5416             case SHF_ALLOC:             *p = 'A'; break;
5417             case SHF_EXECINSTR:         *p = 'X'; break;
5418             case SHF_MERGE:             *p = 'M'; break;
5419             case SHF_STRINGS:           *p = 'S'; break;
5420             case SHF_INFO_LINK:         *p = 'I'; break;
5421             case SHF_LINK_ORDER:        *p = 'L'; break;
5422             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5423             case SHF_GROUP:             *p = 'G'; break;
5424             case SHF_TLS:               *p = 'T'; break;
5425             case SHF_EXCLUDE:           *p = 'E'; break;
5426             case SHF_COMPRESSED:        *p = 'C'; break;
5427
5428             default:
5429               if ((elf_header.e_machine == EM_X86_64
5430                    || elf_header.e_machine == EM_L1OM
5431                    || elf_header.e_machine == EM_K1OM)
5432                   && flag == SHF_X86_64_LARGE)
5433                 *p = 'l';
5434               else if (elf_header.e_machine == EM_ARM
5435                        && flag == SHF_ARM_NOREAD)
5436                   *p = 'y';
5437               else if (flag & SHF_MASKOS)
5438                 {
5439                   *p = 'o';
5440                   sh_flags &= ~ SHF_MASKOS;
5441                 }
5442               else if (flag & SHF_MASKPROC)
5443                 {
5444                   *p = 'p';
5445                   sh_flags &= ~ SHF_MASKPROC;
5446                 }
5447               else
5448                 *p = 'x';
5449               break;
5450             }
5451           p++;
5452         }
5453     }
5454
5455   if (do_section_details)
5456     {
5457       if (os_flags)
5458         {
5459           size -= 5 + field_size;
5460           if (p != buff + field_size + 4)
5461             {
5462               if (size < (2 + 1))
5463                 {
5464                   warn (_("Internal error: not enough buffer room for section flag info"));
5465                   return _("<unknown>");
5466                 }
5467               size -= 2;
5468               *p++ = ',';
5469               *p++ = ' ';
5470             }
5471           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5472                    (unsigned long) os_flags);
5473           p += 5 + field_size;
5474         }
5475       if (proc_flags)
5476         {
5477           size -= 7 + field_size;
5478           if (p != buff + field_size + 4)
5479             {
5480               if (size < (2 + 1))
5481                 {
5482                   warn (_("Internal error: not enough buffer room for section flag info"));
5483                   return _("<unknown>");
5484                 }
5485               size -= 2;
5486               *p++ = ',';
5487               *p++ = ' ';
5488             }
5489           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5490                    (unsigned long) proc_flags);
5491           p += 7 + field_size;
5492         }
5493       if (unknown_flags)
5494         {
5495           size -= 10 + field_size;
5496           if (p != buff + field_size + 4)
5497             {
5498               if (size < (2 + 1))
5499                 {
5500                   warn (_("Internal error: not enough buffer room for section flag info"));
5501                   return _("<unknown>");
5502                 }
5503               size -= 2;
5504               *p++ = ',';
5505               *p++ = ' ';
5506             }
5507           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5508                    (unsigned long) unknown_flags);
5509           p += 10 + field_size;
5510         }
5511     }
5512
5513   *p = '\0';
5514   return buff;
5515 }
5516
5517 static unsigned int
5518 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5519 {
5520   if (is_32bit_elf)
5521     {
5522       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5523       chdr->ch_type = BYTE_GET (echdr->ch_type);
5524       chdr->ch_size = BYTE_GET (echdr->ch_size);
5525       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5526       return sizeof (*echdr);
5527     }
5528   else
5529     {
5530       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5531       chdr->ch_type = BYTE_GET (echdr->ch_type);
5532       chdr->ch_size = BYTE_GET (echdr->ch_size);
5533       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5534       return sizeof (*echdr);
5535     }
5536 }
5537
5538 static int
5539 process_section_headers (FILE * file)
5540 {
5541   Elf_Internal_Shdr * section;
5542   unsigned int i;
5543
5544   section_headers = NULL;
5545
5546   if (elf_header.e_shnum == 0)
5547     {
5548       /* PR binutils/12467.  */
5549       if (elf_header.e_shoff != 0)
5550         warn (_("possibly corrupt ELF file header - it has a non-zero"
5551                 " section header offset, but no section headers\n"));
5552       else if (do_sections)
5553         printf (_("\nThere are no sections in this file.\n"));
5554
5555       return 1;
5556     }
5557
5558   if (do_sections && !do_header)
5559     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5560             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5561
5562   if (is_32bit_elf)
5563     {
5564       if (! get_32bit_section_headers (file, FALSE))
5565         return 0;
5566     }
5567   else if (! get_64bit_section_headers (file, FALSE))
5568     return 0;
5569
5570   /* Read in the string table, so that we have names to display.  */
5571   if (elf_header.e_shstrndx != SHN_UNDEF
5572        && elf_header.e_shstrndx < elf_header.e_shnum)
5573     {
5574       section = section_headers + elf_header.e_shstrndx;
5575
5576       if (section->sh_size != 0)
5577         {
5578           string_table = (char *) get_data (NULL, file, section->sh_offset,
5579                                             1, section->sh_size,
5580                                             _("string table"));
5581
5582           string_table_length = string_table != NULL ? section->sh_size : 0;
5583         }
5584     }
5585
5586   /* Scan the sections for the dynamic symbol table
5587      and dynamic string table and debug sections.  */
5588   dynamic_symbols = NULL;
5589   dynamic_strings = NULL;
5590   dynamic_syminfo = NULL;
5591   symtab_shndx_list = NULL;
5592
5593   eh_addr_size = is_32bit_elf ? 4 : 8;
5594   switch (elf_header.e_machine)
5595     {
5596     case EM_MIPS:
5597     case EM_MIPS_RS3_LE:
5598       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5599          FDE addresses.  However, the ABI also has a semi-official ILP32
5600          variant for which the normal FDE address size rules apply.
5601
5602          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5603          section, where XX is the size of longs in bits.  Unfortunately,
5604          earlier compilers provided no way of distinguishing ILP32 objects
5605          from LP64 objects, so if there's any doubt, we should assume that
5606          the official LP64 form is being used.  */
5607       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5608           && find_section (".gcc_compiled_long32") == NULL)
5609         eh_addr_size = 8;
5610       break;
5611
5612     case EM_H8_300:
5613     case EM_H8_300H:
5614       switch (elf_header.e_flags & EF_H8_MACH)
5615         {
5616         case E_H8_MACH_H8300:
5617         case E_H8_MACH_H8300HN:
5618         case E_H8_MACH_H8300SN:
5619         case E_H8_MACH_H8300SXN:
5620           eh_addr_size = 2;
5621           break;
5622         case E_H8_MACH_H8300H:
5623         case E_H8_MACH_H8300S:
5624         case E_H8_MACH_H8300SX:
5625           eh_addr_size = 4;
5626           break;
5627         }
5628       break;
5629
5630     case EM_M32C_OLD:
5631     case EM_M32C:
5632       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5633         {
5634         case EF_M32C_CPU_M16C:
5635           eh_addr_size = 2;
5636           break;
5637         }
5638       break;
5639     }
5640
5641 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5642   do                                                                    \
5643     {                                                                   \
5644       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5645       if (section->sh_entsize != expected_entsize)                      \
5646         {                                                               \
5647           char buf[40];                                                 \
5648           sprintf_vma (buf, section->sh_entsize);                       \
5649           /* Note: coded this way so that there is a single string for  \
5650              translation.  */ \
5651           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5652           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5653                    (unsigned) expected_entsize);                        \
5654           section->sh_entsize = expected_entsize;                       \
5655         }                                                               \
5656     }                                                                   \
5657   while (0)
5658
5659 #define CHECK_ENTSIZE(section, i, type)                                 \
5660   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5661                         sizeof (Elf64_External_##type))
5662
5663   for (i = 0, section = section_headers;
5664        i < elf_header.e_shnum;
5665        i++, section++)
5666     {
5667       char * name = SECTION_NAME (section);
5668
5669       if (section->sh_type == SHT_DYNSYM)
5670         {
5671           if (dynamic_symbols != NULL)
5672             {
5673               error (_("File contains multiple dynamic symbol tables\n"));
5674               continue;
5675             }
5676
5677           CHECK_ENTSIZE (section, i, Sym);
5678           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5679         }
5680       else if (section->sh_type == SHT_STRTAB
5681                && streq (name, ".dynstr"))
5682         {
5683           if (dynamic_strings != NULL)
5684             {
5685               error (_("File contains multiple dynamic string tables\n"));
5686               continue;
5687             }
5688
5689           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5690                                                1, section->sh_size,
5691                                                _("dynamic strings"));
5692           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5693         }
5694       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5695         {
5696           elf_section_list * entry = xmalloc (sizeof * entry);
5697           entry->hdr = section;
5698           entry->next = symtab_shndx_list;
5699           symtab_shndx_list = entry;
5700         }
5701       else if (section->sh_type == SHT_SYMTAB)
5702         CHECK_ENTSIZE (section, i, Sym);
5703       else if (section->sh_type == SHT_GROUP)
5704         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5705       else if (section->sh_type == SHT_REL)
5706         CHECK_ENTSIZE (section, i, Rel);
5707       else if (section->sh_type == SHT_RELA)
5708         CHECK_ENTSIZE (section, i, Rela);
5709       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5710                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5711                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5712                 || do_debug_str || do_debug_loc || do_debug_ranges
5713                 || do_debug_addr || do_debug_cu_index)
5714                && (const_strneq (name, ".debug_")
5715                    || const_strneq (name, ".zdebug_")))
5716         {
5717           if (name[1] == 'z')
5718             name += sizeof (".zdebug_") - 1;
5719           else
5720             name += sizeof (".debug_") - 1;
5721
5722           if (do_debugging
5723               || (do_debug_info     && const_strneq (name, "info"))
5724               || (do_debug_info     && const_strneq (name, "types"))
5725               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5726               || (do_debug_lines    && strcmp (name, "line") == 0)
5727               || (do_debug_lines    && const_strneq (name, "line."))
5728               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5729               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5730               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5731               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5732               || (do_debug_aranges  && const_strneq (name, "aranges"))
5733               || (do_debug_ranges   && const_strneq (name, "ranges"))
5734               || (do_debug_frames   && const_strneq (name, "frame"))
5735               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5736               || (do_debug_macinfo  && const_strneq (name, "macro"))
5737               || (do_debug_str      && const_strneq (name, "str"))
5738               || (do_debug_loc      && const_strneq (name, "loc"))
5739               || (do_debug_addr     && const_strneq (name, "addr"))
5740               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5741               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5742               )
5743             request_dump_bynumber (i, DEBUG_DUMP);
5744         }
5745       /* Linkonce section to be combined with .debug_info at link time.  */
5746       else if ((do_debugging || do_debug_info)
5747                && const_strneq (name, ".gnu.linkonce.wi."))
5748         request_dump_bynumber (i, DEBUG_DUMP);
5749       else if (do_debug_frames && streq (name, ".eh_frame"))
5750         request_dump_bynumber (i, DEBUG_DUMP);
5751       else if (do_gdb_index && streq (name, ".gdb_index"))
5752         request_dump_bynumber (i, DEBUG_DUMP);
5753       /* Trace sections for Itanium VMS.  */
5754       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5755                 || do_trace_aranges)
5756                && const_strneq (name, ".trace_"))
5757         {
5758           name += sizeof (".trace_") - 1;
5759
5760           if (do_debugging
5761               || (do_trace_info     && streq (name, "info"))
5762               || (do_trace_abbrevs  && streq (name, "abbrev"))
5763               || (do_trace_aranges  && streq (name, "aranges"))
5764               )
5765             request_dump_bynumber (i, DEBUG_DUMP);
5766         }
5767     }
5768
5769   if (! do_sections)
5770     return 1;
5771
5772   if (elf_header.e_shnum > 1)
5773     printf (_("\nSection Headers:\n"));
5774   else
5775     printf (_("\nSection Header:\n"));
5776
5777   if (is_32bit_elf)
5778     {
5779       if (do_section_details)
5780         {
5781           printf (_("  [Nr] Name\n"));
5782           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5783         }
5784       else
5785         printf
5786           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5787     }
5788   else if (do_wide)
5789     {
5790       if (do_section_details)
5791         {
5792           printf (_("  [Nr] Name\n"));
5793           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5794         }
5795       else
5796         printf
5797           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5798     }
5799   else
5800     {
5801       if (do_section_details)
5802         {
5803           printf (_("  [Nr] Name\n"));
5804           printf (_("       Type              Address          Offset            Link\n"));
5805           printf (_("       Size              EntSize          Info              Align\n"));
5806         }
5807       else
5808         {
5809           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5810           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5811         }
5812     }
5813
5814   if (do_section_details)
5815     printf (_("       Flags\n"));
5816
5817   for (i = 0, section = section_headers;
5818        i < elf_header.e_shnum;
5819        i++, section++)
5820     {
5821       printf ("  [%2u] ", i);
5822       if (do_section_details)
5823         printf ("%s\n      ", printable_section_name (section));
5824       else
5825         print_symbol (-17, SECTION_NAME (section));
5826
5827       printf (do_wide ? " %-15s " : " %-15.15s ",
5828               get_section_type_name (section->sh_type));
5829
5830       if (is_32bit_elf)
5831         {
5832           const char * link_too_big = NULL;
5833
5834           print_vma (section->sh_addr, LONG_HEX);
5835
5836           printf ( " %6.6lx %6.6lx %2.2lx",
5837                    (unsigned long) section->sh_offset,
5838                    (unsigned long) section->sh_size,
5839                    (unsigned long) section->sh_entsize);
5840
5841           if (do_section_details)
5842             fputs ("  ", stdout);
5843           else
5844             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5845
5846           if (section->sh_link >= elf_header.e_shnum)
5847             {
5848               link_too_big = "";
5849               /* The sh_link value is out of range.  Normally this indicates
5850                  an error but it can have special values in Solaris binaries.  */
5851               switch (elf_header.e_machine)
5852                 {
5853                 case EM_386:
5854                 case EM_IAMCU:
5855                 case EM_X86_64:
5856                 case EM_L1OM:
5857                 case EM_K1OM:
5858                 case EM_OLD_SPARCV9:
5859                 case EM_SPARC32PLUS:
5860                 case EM_SPARCV9:
5861                 case EM_SPARC:
5862                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5863                     link_too_big = "BEFORE";
5864                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5865                     link_too_big = "AFTER";
5866                   break;
5867                 default:
5868                   break;
5869                 }
5870             }
5871
5872           if (do_section_details)
5873             {
5874               if (link_too_big != NULL && * link_too_big)
5875                 printf ("<%s> ", link_too_big);
5876               else
5877                 printf ("%2u ", section->sh_link);
5878               printf ("%3u %2lu\n", section->sh_info,
5879                       (unsigned long) section->sh_addralign);
5880             }
5881           else
5882             printf ("%2u %3u %2lu\n",
5883                     section->sh_link,
5884                     section->sh_info,
5885                     (unsigned long) section->sh_addralign);
5886
5887           if (link_too_big && ! * link_too_big)
5888             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5889                   i, section->sh_link);
5890         }
5891       else if (do_wide)
5892         {
5893           print_vma (section->sh_addr, LONG_HEX);
5894
5895           if ((long) section->sh_offset == section->sh_offset)
5896             printf (" %6.6lx", (unsigned long) section->sh_offset);
5897           else
5898             {
5899               putchar (' ');
5900               print_vma (section->sh_offset, LONG_HEX);
5901             }
5902
5903           if ((unsigned long) section->sh_size == section->sh_size)
5904             printf (" %6.6lx", (unsigned long) section->sh_size);
5905           else
5906             {
5907               putchar (' ');
5908               print_vma (section->sh_size, LONG_HEX);
5909             }
5910
5911           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5912             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5913           else
5914             {
5915               putchar (' ');
5916               print_vma (section->sh_entsize, LONG_HEX);
5917             }
5918
5919           if (do_section_details)
5920             fputs ("  ", stdout);
5921           else
5922             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5923
5924           printf ("%2u %3u ", section->sh_link, section->sh_info);
5925
5926           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5927             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5928           else
5929             {
5930               print_vma (section->sh_addralign, DEC);
5931               putchar ('\n');
5932             }
5933         }
5934       else if (do_section_details)
5935         {
5936           printf ("       %-15.15s  ",
5937                   get_section_type_name (section->sh_type));
5938           print_vma (section->sh_addr, LONG_HEX);
5939           if ((long) section->sh_offset == section->sh_offset)
5940             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5941           else
5942             {
5943               printf ("  ");
5944               print_vma (section->sh_offset, LONG_HEX);
5945             }
5946           printf ("  %u\n       ", section->sh_link);
5947           print_vma (section->sh_size, LONG_HEX);
5948           putchar (' ');
5949           print_vma (section->sh_entsize, LONG_HEX);
5950
5951           printf ("  %-16u  %lu\n",
5952                   section->sh_info,
5953                   (unsigned long) section->sh_addralign);
5954         }
5955       else
5956         {
5957           putchar (' ');
5958           print_vma (section->sh_addr, LONG_HEX);
5959           if ((long) section->sh_offset == section->sh_offset)
5960             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5961           else
5962             {
5963               printf ("  ");
5964               print_vma (section->sh_offset, LONG_HEX);
5965             }
5966           printf ("\n       ");
5967           print_vma (section->sh_size, LONG_HEX);
5968           printf ("  ");
5969           print_vma (section->sh_entsize, LONG_HEX);
5970
5971           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5972
5973           printf ("     %2u   %3u     %lu\n",
5974                   section->sh_link,
5975                   section->sh_info,
5976                   (unsigned long) section->sh_addralign);
5977         }
5978
5979       if (do_section_details)
5980         {
5981           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5982           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5983             {
5984               /* Minimum section size is 12 bytes for 32-bit compression
5985                  header + 12 bytes for compressed data header.  */
5986               unsigned char buf[24];
5987               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5988               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5989                             sizeof (buf), _("compression header")))
5990                 {
5991                   Elf_Internal_Chdr chdr;
5992                   get_compression_header (&chdr, buf);
5993                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5994                     printf ("       ZLIB, ");
5995                   else
5996                     printf (_("       [<unknown>: 0x%x], "),
5997                             chdr.ch_type);
5998                   print_vma (chdr.ch_size, LONG_HEX);
5999                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6000                 }
6001             }
6002         }
6003     }
6004
6005   if (!do_section_details)
6006     {
6007       /* The ordering of the letters shown here matches the ordering of the
6008          corresponding SHF_xxx values, and hence the order in which these
6009          letters will be displayed to the user.  */
6010       printf (_("Key to Flags:\n\
6011   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6012   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6013   C (compressed), x (unknown), o (OS specific), E (exclude),\n"));
6014       if (elf_header.e_machine == EM_X86_64
6015           || elf_header.e_machine == EM_L1OM
6016           || elf_header.e_machine == EM_K1OM)
6017         printf (_("l (large), "));
6018       else if (elf_header.e_machine == EM_ARM)
6019         printf (_("y (noread), "));
6020       printf ("p (processor specific)\n");
6021     }
6022
6023   return 1;
6024 }
6025
6026 static const char *
6027 get_group_flags (unsigned int flags)
6028 {
6029   static char buff[32];
6030   switch (flags)
6031     {
6032     case 0:
6033       return "";
6034
6035     case GRP_COMDAT:
6036       return "COMDAT ";
6037
6038    default:
6039       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
6040       break;
6041     }
6042   return buff;
6043 }
6044
6045 static int
6046 process_section_groups (FILE * file)
6047 {
6048   Elf_Internal_Shdr * section;
6049   unsigned int i;
6050   struct group * group;
6051   Elf_Internal_Shdr * symtab_sec;
6052   Elf_Internal_Shdr * strtab_sec;
6053   Elf_Internal_Sym * symtab;
6054   unsigned long num_syms;
6055   char * strtab;
6056   size_t strtab_size;
6057
6058   /* Don't process section groups unless needed.  */
6059   if (!do_unwind && !do_section_groups)
6060     return 1;
6061
6062   if (elf_header.e_shnum == 0)
6063     {
6064       if (do_section_groups)
6065         printf (_("\nThere are no sections to group in this file.\n"));
6066
6067       return 1;
6068     }
6069
6070   if (section_headers == NULL)
6071     {
6072       error (_("Section headers are not available!\n"));
6073       /* PR 13622: This can happen with a corrupt ELF header.  */
6074       return 0;
6075     }
6076
6077   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6078                                                      sizeof (struct group *));
6079
6080   if (section_headers_groups == NULL)
6081     {
6082       error (_("Out of memory reading %u section group headers\n"),
6083              elf_header.e_shnum);
6084       return 0;
6085     }
6086
6087   /* Scan the sections for the group section.  */
6088   group_count = 0;
6089   for (i = 0, section = section_headers;
6090        i < elf_header.e_shnum;
6091        i++, section++)
6092     if (section->sh_type == SHT_GROUP)
6093       group_count++;
6094
6095   if (group_count == 0)
6096     {
6097       if (do_section_groups)
6098         printf (_("\nThere are no section groups in this file.\n"));
6099
6100       return 1;
6101     }
6102
6103   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6104
6105   if (section_groups == NULL)
6106     {
6107       error (_("Out of memory reading %lu groups\n"),
6108              (unsigned long) group_count);
6109       return 0;
6110     }
6111
6112   symtab_sec = NULL;
6113   strtab_sec = NULL;
6114   symtab = NULL;
6115   num_syms = 0;
6116   strtab = NULL;
6117   strtab_size = 0;
6118   for (i = 0, section = section_headers, group = section_groups;
6119        i < elf_header.e_shnum;
6120        i++, section++)
6121     {
6122       if (section->sh_type == SHT_GROUP)
6123         {
6124           const char * name = printable_section_name (section);
6125           const char * group_name;
6126           unsigned char * start;
6127           unsigned char * indices;
6128           unsigned int entry, j, size;
6129           Elf_Internal_Shdr * sec;
6130           Elf_Internal_Sym * sym;
6131
6132           /* Get the symbol table.  */
6133           if (section->sh_link >= elf_header.e_shnum
6134               || ((sec = section_headers + section->sh_link)->sh_type
6135                   != SHT_SYMTAB))
6136             {
6137               error (_("Bad sh_link in group section `%s'\n"), name);
6138               continue;
6139             }
6140
6141           if (symtab_sec != sec)
6142             {
6143               symtab_sec = sec;
6144               if (symtab)
6145                 free (symtab);
6146               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6147             }
6148
6149           if (symtab == NULL)
6150             {
6151               error (_("Corrupt header in group section `%s'\n"), name);
6152               continue;
6153             }
6154
6155           if (section->sh_info >= num_syms)
6156             {
6157               error (_("Bad sh_info in group section `%s'\n"), name);
6158               continue;
6159             }
6160
6161           sym = symtab + section->sh_info;
6162
6163           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6164             {
6165               if (sym->st_shndx == 0
6166                   || sym->st_shndx >= elf_header.e_shnum)
6167                 {
6168                   error (_("Bad sh_info in group section `%s'\n"), name);
6169                   continue;
6170                 }
6171
6172               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6173               strtab_sec = NULL;
6174               if (strtab)
6175                 free (strtab);
6176               strtab = NULL;
6177               strtab_size = 0;
6178             }
6179           else
6180             {
6181               /* Get the string table.  */
6182               if (symtab_sec->sh_link >= elf_header.e_shnum)
6183                 {
6184                   strtab_sec = NULL;
6185                   if (strtab)
6186                     free (strtab);
6187                   strtab = NULL;
6188                   strtab_size = 0;
6189                 }
6190               else if (strtab_sec
6191                        != (sec = section_headers + symtab_sec->sh_link))
6192                 {
6193                   strtab_sec = sec;
6194                   if (strtab)
6195                     free (strtab);
6196
6197                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6198                                               1, strtab_sec->sh_size,
6199                                               _("string table"));
6200                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6201                 }
6202               group_name = sym->st_name < strtab_size
6203                 ? strtab + sym->st_name : _("<corrupt>");
6204             }
6205
6206           /* PR 17531: file: loop.  */
6207           if (section->sh_entsize > section->sh_size)
6208             {
6209               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6210                      printable_section_name (section),
6211                      (unsigned long) section->sh_entsize,
6212                      (unsigned long) section->sh_size);
6213               break;
6214             }
6215
6216           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6217                                               1, section->sh_size,
6218                                               _("section data"));
6219           if (start == NULL)
6220             continue;
6221
6222           indices = start;
6223           size = (section->sh_size / section->sh_entsize) - 1;
6224           entry = byte_get (indices, 4);
6225           indices += 4;
6226
6227           if (do_section_groups)
6228             {
6229               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6230                       get_group_flags (entry), i, name, group_name, size);
6231
6232               printf (_("   [Index]    Name\n"));
6233             }
6234
6235           group->group_index = i;
6236
6237           for (j = 0; j < size; j++)
6238             {
6239               struct group_list * g;
6240
6241               entry = byte_get (indices, 4);
6242               indices += 4;
6243
6244               if (entry >= elf_header.e_shnum)
6245                 {
6246                   static unsigned num_group_errors = 0;
6247
6248                   if (num_group_errors ++ < 10)
6249                     {
6250                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6251                              entry, i, elf_header.e_shnum - 1);
6252                       if (num_group_errors == 10)
6253                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6254                     }
6255                   continue;
6256                 }
6257
6258               if (section_headers_groups [entry] != NULL)
6259                 {
6260                   if (entry)
6261                     {
6262                       static unsigned num_errs = 0;
6263
6264                       if (num_errs ++ < 10)
6265                         {
6266                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6267                                  entry, i,
6268                                  section_headers_groups [entry]->group_index);
6269                           if (num_errs == 10)
6270                             warn (_("Further error messages about already contained group sections suppressed\n"));
6271                         }
6272                       continue;
6273                     }
6274                   else
6275                     {
6276                       /* Intel C/C++ compiler may put section 0 in a
6277                          section group. We just warn it the first time
6278                          and ignore it afterwards.  */
6279                       static int warned = 0;
6280                       if (!warned)
6281                         {
6282                           error (_("section 0 in group section [%5u]\n"),
6283                                  section_headers_groups [entry]->group_index);
6284                           warned++;
6285                         }
6286                     }
6287                 }
6288
6289               section_headers_groups [entry] = group;
6290
6291               if (do_section_groups)
6292                 {
6293                   sec = section_headers + entry;
6294                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6295                 }
6296
6297               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6298               g->section_index = entry;
6299               g->next = group->root;
6300               group->root = g;
6301             }
6302
6303           if (start)
6304             free (start);
6305
6306           group++;
6307         }
6308     }
6309
6310   if (symtab)
6311     free (symtab);
6312   if (strtab)
6313     free (strtab);
6314   return 1;
6315 }
6316
6317 /* Data used to display dynamic fixups.  */
6318
6319 struct ia64_vms_dynfixup
6320 {
6321   bfd_vma needed_ident;         /* Library ident number.  */
6322   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6323   bfd_vma fixup_needed;         /* Index of the library.  */
6324   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6325   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6326 };
6327
6328 /* Data used to display dynamic relocations.  */
6329
6330 struct ia64_vms_dynimgrela
6331 {
6332   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6333   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6334 };
6335
6336 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6337    library).  */
6338
6339 static void
6340 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6341                               const char *strtab, unsigned int strtab_sz)
6342 {
6343   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6344   long i;
6345   const char *lib_name;
6346
6347   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6348                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6349                    _("dynamic section image fixups"));
6350   if (!imfs)
6351     return;
6352
6353   if (fixup->needed < strtab_sz)
6354     lib_name = strtab + fixup->needed;
6355   else
6356     {
6357       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6358             (unsigned long) fixup->needed);
6359       lib_name = "???";
6360     }
6361   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6362           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6363   printf
6364     (_("Seg Offset           Type                             SymVec DataType\n"));
6365
6366   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6367     {
6368       unsigned int type;
6369       const char *rtype;
6370
6371       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6372       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6373       type = BYTE_GET (imfs [i].type);
6374       rtype = elf_ia64_reloc_type (type);
6375       if (rtype == NULL)
6376         printf (" 0x%08x                       ", type);
6377       else
6378         printf (" %-32s ", rtype);
6379       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6380       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6381     }
6382
6383   free (imfs);
6384 }
6385
6386 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6387
6388 static void
6389 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6390 {
6391   Elf64_External_VMS_IMAGE_RELA *imrs;
6392   long i;
6393
6394   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6395                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6396                    _("dynamic section image relocations"));
6397   if (!imrs)
6398     return;
6399
6400   printf (_("\nImage relocs\n"));
6401   printf
6402     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6403
6404   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6405     {
6406       unsigned int type;
6407       const char *rtype;
6408
6409       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6410       printf ("%08" BFD_VMA_FMT "x ",
6411               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6412       type = BYTE_GET (imrs [i].type);
6413       rtype = elf_ia64_reloc_type (type);
6414       if (rtype == NULL)
6415         printf ("0x%08x                      ", type);
6416       else
6417         printf ("%-31s ", rtype);
6418       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6419       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6420       printf ("%08" BFD_VMA_FMT "x\n",
6421               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6422     }
6423
6424   free (imrs);
6425 }
6426
6427 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6428
6429 static int
6430 process_ia64_vms_dynamic_relocs (FILE *file)
6431 {
6432   struct ia64_vms_dynfixup fixup;
6433   struct ia64_vms_dynimgrela imgrela;
6434   Elf_Internal_Dyn *entry;
6435   int res = 0;
6436   bfd_vma strtab_off = 0;
6437   bfd_vma strtab_sz = 0;
6438   char *strtab = NULL;
6439
6440   memset (&fixup, 0, sizeof (fixup));
6441   memset (&imgrela, 0, sizeof (imgrela));
6442
6443   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6444   for (entry = dynamic_section;
6445        entry < dynamic_section + dynamic_nent;
6446        entry++)
6447     {
6448       switch (entry->d_tag)
6449         {
6450         case DT_IA_64_VMS_STRTAB_OFFSET:
6451           strtab_off = entry->d_un.d_val;
6452           break;
6453         case DT_STRSZ:
6454           strtab_sz = entry->d_un.d_val;
6455           if (strtab == NULL)
6456             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6457                                1, strtab_sz, _("dynamic string section"));
6458           break;
6459
6460         case DT_IA_64_VMS_NEEDED_IDENT:
6461           fixup.needed_ident = entry->d_un.d_val;
6462           break;
6463         case DT_NEEDED:
6464           fixup.needed = entry->d_un.d_val;
6465           break;
6466         case DT_IA_64_VMS_FIXUP_NEEDED:
6467           fixup.fixup_needed = entry->d_un.d_val;
6468           break;
6469         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6470           fixup.fixup_rela_cnt = entry->d_un.d_val;
6471           break;
6472         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6473           fixup.fixup_rela_off = entry->d_un.d_val;
6474           res++;
6475           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6476           break;
6477
6478         case DT_IA_64_VMS_IMG_RELA_CNT:
6479           imgrela.img_rela_cnt = entry->d_un.d_val;
6480           break;
6481         case DT_IA_64_VMS_IMG_RELA_OFF:
6482           imgrela.img_rela_off = entry->d_un.d_val;
6483           res++;
6484           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6485           break;
6486
6487         default:
6488           break;
6489         }
6490     }
6491
6492   if (strtab != NULL)
6493     free (strtab);
6494
6495   return res;
6496 }
6497
6498 static struct
6499 {
6500   const char * name;
6501   int reloc;
6502   int size;
6503   int rela;
6504 } dynamic_relocations [] =
6505 {
6506     { "REL", DT_REL, DT_RELSZ, FALSE },
6507     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6508     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6509 };
6510
6511 /* Process the reloc section.  */
6512
6513 static int
6514 process_relocs (FILE * file)
6515 {
6516   unsigned long rel_size;
6517   unsigned long rel_offset;
6518
6519
6520   if (!do_reloc)
6521     return 1;
6522
6523   if (do_using_dynamic)
6524     {
6525       int is_rela;
6526       const char * name;
6527       int has_dynamic_reloc;
6528       unsigned int i;
6529
6530       has_dynamic_reloc = 0;
6531
6532       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6533         {
6534           is_rela = dynamic_relocations [i].rela;
6535           name = dynamic_relocations [i].name;
6536           rel_size = dynamic_info [dynamic_relocations [i].size];
6537           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6538
6539           has_dynamic_reloc |= rel_size;
6540
6541           if (is_rela == UNKNOWN)
6542             {
6543               if (dynamic_relocations [i].reloc == DT_JMPREL)
6544                 switch (dynamic_info[DT_PLTREL])
6545                   {
6546                   case DT_REL:
6547                     is_rela = FALSE;
6548                     break;
6549                   case DT_RELA:
6550                     is_rela = TRUE;
6551                     break;
6552                   }
6553             }
6554
6555           if (rel_size)
6556             {
6557               printf
6558                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6559                  name, rel_offset, rel_size);
6560
6561               dump_relocations (file,
6562                                 offset_from_vma (file, rel_offset, rel_size),
6563                                 rel_size,
6564                                 dynamic_symbols, num_dynamic_syms,
6565                                 dynamic_strings, dynamic_strings_length,
6566                                 is_rela, 1);
6567             }
6568         }
6569
6570       if (is_ia64_vms ())
6571         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6572
6573       if (! has_dynamic_reloc)
6574         printf (_("\nThere are no dynamic relocations in this file.\n"));
6575     }
6576   else
6577     {
6578       Elf_Internal_Shdr * section;
6579       unsigned long i;
6580       int found = 0;
6581
6582       for (i = 0, section = section_headers;
6583            i < elf_header.e_shnum;
6584            i++, section++)
6585         {
6586           if (   section->sh_type != SHT_RELA
6587               && section->sh_type != SHT_REL)
6588             continue;
6589
6590           rel_offset = section->sh_offset;
6591           rel_size   = section->sh_size;
6592
6593           if (rel_size)
6594             {
6595               Elf_Internal_Shdr * strsec;
6596               int is_rela;
6597
6598               printf (_("\nRelocation section "));
6599
6600               if (string_table == NULL)
6601                 printf ("%d", section->sh_name);
6602               else
6603                 printf ("'%s'", printable_section_name (section));
6604
6605               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6606                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6607
6608               is_rela = section->sh_type == SHT_RELA;
6609
6610               if (section->sh_link != 0
6611                   && section->sh_link < elf_header.e_shnum)
6612                 {
6613                   Elf_Internal_Shdr * symsec;
6614                   Elf_Internal_Sym *  symtab;
6615                   unsigned long nsyms;
6616                   unsigned long strtablen = 0;
6617                   char * strtab = NULL;
6618
6619                   symsec = section_headers + section->sh_link;
6620                   if (symsec->sh_type != SHT_SYMTAB
6621                       && symsec->sh_type != SHT_DYNSYM)
6622                     continue;
6623
6624                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6625
6626                   if (symtab == NULL)
6627                     continue;
6628
6629                   if (symsec->sh_link != 0
6630                       && symsec->sh_link < elf_header.e_shnum)
6631                     {
6632                       strsec = section_headers + symsec->sh_link;
6633
6634                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6635                                                   1, strsec->sh_size,
6636                                                   _("string table"));
6637                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6638                     }
6639
6640                   dump_relocations (file, rel_offset, rel_size,
6641                                     symtab, nsyms, strtab, strtablen,
6642                                     is_rela,
6643                                     symsec->sh_type == SHT_DYNSYM);
6644                   if (strtab)
6645                     free (strtab);
6646                   free (symtab);
6647                 }
6648               else
6649                 dump_relocations (file, rel_offset, rel_size,
6650                                   NULL, 0, NULL, 0, is_rela, 0);
6651
6652               found = 1;
6653             }
6654         }
6655
6656       if (! found)
6657         printf (_("\nThere are no relocations in this file.\n"));
6658     }
6659
6660   return 1;
6661 }
6662
6663 /* An absolute address consists of a section and an offset.  If the
6664    section is NULL, the offset itself is the address, otherwise, the
6665    address equals to LOAD_ADDRESS(section) + offset.  */
6666
6667 struct absaddr
6668 {
6669   unsigned short section;
6670   bfd_vma offset;
6671 };
6672
6673 #define ABSADDR(a) \
6674   ((a).section \
6675    ? section_headers [(a).section].sh_addr + (a).offset \
6676    : (a).offset)
6677
6678 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6679    name, if found, and the offset from the symbol to ADDR.  */
6680
6681 static void
6682 find_symbol_for_address (Elf_Internal_Sym * symtab,
6683                          unsigned long      nsyms,
6684                          const char *       strtab,
6685                          unsigned long      strtab_size,
6686                          struct absaddr     addr,
6687                          const char **      symname,
6688                          bfd_vma *          offset)
6689 {
6690   bfd_vma dist = 0x100000;
6691   Elf_Internal_Sym * sym;
6692   Elf_Internal_Sym * beg;
6693   Elf_Internal_Sym * end;
6694   Elf_Internal_Sym * best = NULL;
6695
6696   REMOVE_ARCH_BITS (addr.offset);
6697   beg = symtab;
6698   end = symtab + nsyms;
6699
6700   while (beg < end)
6701     {
6702       bfd_vma value;
6703
6704       sym = beg + (end - beg) / 2;
6705
6706       value = sym->st_value;
6707       REMOVE_ARCH_BITS (value);
6708
6709       if (sym->st_name != 0
6710           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6711           && addr.offset >= value
6712           && addr.offset - value < dist)
6713         {
6714           best = sym;
6715           dist = addr.offset - value;
6716           if (!dist)
6717             break;
6718         }
6719
6720       if (addr.offset < value)
6721         end = sym;
6722       else
6723         beg = sym + 1;
6724     }
6725
6726   if (best)
6727     {
6728       *symname = (best->st_name >= strtab_size
6729                   ? _("<corrupt>") : strtab + best->st_name);
6730       *offset = dist;
6731       return;
6732     }
6733
6734   *symname = NULL;
6735   *offset = addr.offset;
6736 }
6737
6738 static int
6739 symcmp (const void *p, const void *q)
6740 {
6741   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6742   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6743
6744   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6745 }
6746
6747 /* Process the unwind section.  */
6748
6749 #include "unwind-ia64.h"
6750
6751 struct ia64_unw_table_entry
6752 {
6753   struct absaddr start;
6754   struct absaddr end;
6755   struct absaddr info;
6756 };
6757
6758 struct ia64_unw_aux_info
6759 {
6760   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6761   unsigned long table_len;              /* Length of unwind table.  */
6762   unsigned char * info;                 /* Unwind info.  */
6763   unsigned long info_size;              /* Size of unwind info.  */
6764   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6765   bfd_vma seg_base;                     /* Starting address of segment.  */
6766   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6767   unsigned long nsyms;                  /* Number of symbols.  */
6768   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6769   unsigned long nfuns;                  /* Number of entries in funtab.  */
6770   char * strtab;                        /* The string table.  */
6771   unsigned long strtab_size;            /* Size of string table.  */
6772 };
6773
6774 static void
6775 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6776 {
6777   struct ia64_unw_table_entry * tp;
6778   unsigned long j, nfuns;
6779   int in_body;
6780
6781   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6782   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6783     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6784       aux->funtab[nfuns++] = aux->symtab[j];
6785   aux->nfuns = nfuns;
6786   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6787
6788   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6789     {
6790       bfd_vma stamp;
6791       bfd_vma offset;
6792       const unsigned char * dp;
6793       const unsigned char * head;
6794       const unsigned char * end;
6795       const char * procname;
6796
6797       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6798                                aux->strtab_size, tp->start, &procname, &offset);
6799
6800       fputs ("\n<", stdout);
6801
6802       if (procname)
6803         {
6804           fputs (procname, stdout);
6805
6806           if (offset)
6807             printf ("+%lx", (unsigned long) offset);
6808         }
6809
6810       fputs (">: [", stdout);
6811       print_vma (tp->start.offset, PREFIX_HEX);
6812       fputc ('-', stdout);
6813       print_vma (tp->end.offset, PREFIX_HEX);
6814       printf ("], info at +0x%lx\n",
6815               (unsigned long) (tp->info.offset - aux->seg_base));
6816
6817       /* PR 17531: file: 86232b32.  */
6818       if (aux->info == NULL)
6819         continue;
6820
6821       /* PR 17531: file: 0997b4d1.  */
6822       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6823         {
6824           warn (_("Invalid offset %lx in table entry %ld\n"),
6825                 (long) tp->info.offset, (long) (tp - aux->table));
6826           continue;
6827         }
6828
6829       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6830       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6831
6832       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6833               (unsigned) UNW_VER (stamp),
6834               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6835               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6836               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6837               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6838
6839       if (UNW_VER (stamp) != 1)
6840         {
6841           printf (_("\tUnknown version.\n"));
6842           continue;
6843         }
6844
6845       in_body = 0;
6846       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6847       /* PR 17531: file: 16ceda89.  */
6848       if (end > aux->info + aux->info_size)
6849         end = aux->info + aux->info_size;
6850       for (dp = head + 8; dp < end;)
6851         dp = unw_decode (dp, in_body, & in_body, end);
6852     }
6853
6854   free (aux->funtab);
6855 }
6856
6857 static bfd_boolean
6858 slurp_ia64_unwind_table (FILE * file,
6859                          struct ia64_unw_aux_info * aux,
6860                          Elf_Internal_Shdr * sec)
6861 {
6862   unsigned long size, nrelas, i;
6863   Elf_Internal_Phdr * seg;
6864   struct ia64_unw_table_entry * tep;
6865   Elf_Internal_Shdr * relsec;
6866   Elf_Internal_Rela * rela;
6867   Elf_Internal_Rela * rp;
6868   unsigned char * table;
6869   unsigned char * tp;
6870   Elf_Internal_Sym * sym;
6871   const char * relname;
6872
6873   aux->table_len = 0;
6874
6875   /* First, find the starting address of the segment that includes
6876      this section: */
6877
6878   if (elf_header.e_phnum)
6879     {
6880       if (! get_program_headers (file))
6881           return FALSE;
6882
6883       for (seg = program_headers;
6884            seg < program_headers + elf_header.e_phnum;
6885            ++seg)
6886         {
6887           if (seg->p_type != PT_LOAD)
6888             continue;
6889
6890           if (sec->sh_addr >= seg->p_vaddr
6891               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6892             {
6893               aux->seg_base = seg->p_vaddr;
6894               break;
6895             }
6896         }
6897     }
6898
6899   /* Second, build the unwind table from the contents of the unwind section:  */
6900   size = sec->sh_size;
6901   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6902                                       _("unwind table"));
6903   if (!table)
6904     return FALSE;
6905
6906   aux->table_len = size / (3 * eh_addr_size);
6907   aux->table = (struct ia64_unw_table_entry *)
6908     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6909   tep = aux->table;
6910
6911   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6912     {
6913       tep->start.section = SHN_UNDEF;
6914       tep->end.section   = SHN_UNDEF;
6915       tep->info.section  = SHN_UNDEF;
6916       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6917       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6918       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6919       tep->start.offset += aux->seg_base;
6920       tep->end.offset   += aux->seg_base;
6921       tep->info.offset  += aux->seg_base;
6922     }
6923   free (table);
6924
6925   /* Third, apply any relocations to the unwind table:  */
6926   for (relsec = section_headers;
6927        relsec < section_headers + elf_header.e_shnum;
6928        ++relsec)
6929     {
6930       if (relsec->sh_type != SHT_RELA
6931           || relsec->sh_info >= elf_header.e_shnum
6932           || section_headers + relsec->sh_info != sec)
6933         continue;
6934
6935       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6936                               & rela, & nrelas))
6937         {
6938           free (aux->table);
6939           aux->table = NULL;
6940           aux->table_len = 0;
6941           return FALSE;
6942         }
6943
6944       for (rp = rela; rp < rela + nrelas; ++rp)
6945         {
6946           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6947           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6948
6949           /* PR 17531: file: 9fa67536.  */
6950           if (relname == NULL)
6951             {
6952               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6953               continue;
6954             }
6955
6956           if (! const_strneq (relname, "R_IA64_SEGREL"))
6957             {
6958               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6959               continue;
6960             }
6961
6962           i = rp->r_offset / (3 * eh_addr_size);
6963
6964           /* PR 17531: file: 5bc8d9bf.  */
6965           if (i >= aux->table_len)
6966             {
6967               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6968               continue;
6969             }
6970
6971           switch (rp->r_offset / eh_addr_size % 3)
6972             {
6973             case 0:
6974               aux->table[i].start.section = sym->st_shndx;
6975               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6976               break;
6977             case 1:
6978               aux->table[i].end.section   = sym->st_shndx;
6979               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6980               break;
6981             case 2:
6982               aux->table[i].info.section  = sym->st_shndx;
6983               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6984               break;
6985             default:
6986               break;
6987             }
6988         }
6989
6990       free (rela);
6991     }
6992
6993   return TRUE;
6994 }
6995
6996 static void
6997 ia64_process_unwind (FILE * file)
6998 {
6999   Elf_Internal_Shdr * sec;
7000   Elf_Internal_Shdr * unwsec = NULL;
7001   Elf_Internal_Shdr * strsec;
7002   unsigned long i, unwcount = 0, unwstart = 0;
7003   struct ia64_unw_aux_info aux;
7004
7005   memset (& aux, 0, sizeof (aux));
7006
7007   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7008     {
7009       if (sec->sh_type == SHT_SYMTAB
7010           && sec->sh_link < elf_header.e_shnum)
7011         {
7012           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7013
7014           strsec = section_headers + sec->sh_link;
7015           if (aux.strtab != NULL)
7016             {
7017               error (_("Multiple auxillary string tables encountered\n"));
7018               free (aux.strtab);
7019             }
7020           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7021                                           1, strsec->sh_size,
7022                                           _("string table"));
7023           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7024         }
7025       else if (sec->sh_type == SHT_IA_64_UNWIND)
7026         unwcount++;
7027     }
7028
7029   if (!unwcount)
7030     printf (_("\nThere are no unwind sections in this file.\n"));
7031
7032   while (unwcount-- > 0)
7033     {
7034       char * suffix;
7035       size_t len, len2;
7036
7037       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7038            i < elf_header.e_shnum; ++i, ++sec)
7039         if (sec->sh_type == SHT_IA_64_UNWIND)
7040           {
7041             unwsec = sec;
7042             break;
7043           }
7044       /* We have already counted the number of SHT_IA64_UNWIND
7045          sections so the loop above should never fail.  */
7046       assert (unwsec != NULL);
7047
7048       unwstart = i + 1;
7049       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7050
7051       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7052         {
7053           /* We need to find which section group it is in.  */
7054           struct group_list * g;
7055
7056           if (section_headers_groups == NULL
7057               || section_headers_groups [i] == NULL)
7058             i = elf_header.e_shnum;
7059           else
7060             {
7061               g = section_headers_groups [i]->root;
7062
7063               for (; g != NULL; g = g->next)
7064                 {
7065                   sec = section_headers + g->section_index;
7066
7067                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7068                     break;
7069                 }
7070
7071               if (g == NULL)
7072                 i = elf_header.e_shnum;
7073             }
7074         }
7075       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7076         {
7077           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7078           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7079           suffix = SECTION_NAME (unwsec) + len;
7080           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7081                ++i, ++sec)
7082             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7083                 && streq (SECTION_NAME (sec) + len2, suffix))
7084               break;
7085         }
7086       else
7087         {
7088           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7089              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7090           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7091           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7092           suffix = "";
7093           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7094             suffix = SECTION_NAME (unwsec) + len;
7095           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7096                ++i, ++sec)
7097             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7098                 && streq (SECTION_NAME (sec) + len2, suffix))
7099               break;
7100         }
7101
7102       if (i == elf_header.e_shnum)
7103         {
7104           printf (_("\nCould not find unwind info section for "));
7105
7106           if (string_table == NULL)
7107             printf ("%d", unwsec->sh_name);
7108           else
7109             printf ("'%s'", printable_section_name (unwsec));
7110         }
7111       else
7112         {
7113           aux.info_addr = sec->sh_addr;
7114           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7115                                                  sec->sh_size,
7116                                                  _("unwind info"));
7117           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7118
7119           printf (_("\nUnwind section "));
7120
7121           if (string_table == NULL)
7122             printf ("%d", unwsec->sh_name);
7123           else
7124             printf ("'%s'", printable_section_name (unwsec));
7125
7126           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7127                   (unsigned long) unwsec->sh_offset,
7128                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7129
7130           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7131               && aux.table_len > 0)
7132             dump_ia64_unwind (& aux);
7133
7134           if (aux.table)
7135             free ((char *) aux.table);
7136           if (aux.info)
7137             free ((char *) aux.info);
7138           aux.table = NULL;
7139           aux.info = NULL;
7140         }
7141     }
7142
7143   if (aux.symtab)
7144     free (aux.symtab);
7145   if (aux.strtab)
7146     free ((char *) aux.strtab);
7147 }
7148
7149 struct hppa_unw_table_entry
7150   {
7151     struct absaddr start;
7152     struct absaddr end;
7153     unsigned int Cannot_unwind:1;               /* 0 */
7154     unsigned int Millicode:1;                   /* 1 */
7155     unsigned int Millicode_save_sr0:1;          /* 2 */
7156     unsigned int Region_description:2;          /* 3..4 */
7157     unsigned int reserved1:1;                   /* 5 */
7158     unsigned int Entry_SR:1;                    /* 6 */
7159     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7160     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7161     unsigned int Args_stored:1;                 /* 16 */
7162     unsigned int Variable_Frame:1;              /* 17 */
7163     unsigned int Separate_Package_Body:1;       /* 18 */
7164     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7165     unsigned int Stack_Overflow_Check:1;        /* 20 */
7166     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7167     unsigned int Ada_Region:1;                  /* 22 */
7168     unsigned int cxx_info:1;                    /* 23 */
7169     unsigned int cxx_try_catch:1;               /* 24 */
7170     unsigned int sched_entry_seq:1;             /* 25 */
7171     unsigned int reserved2:1;                   /* 26 */
7172     unsigned int Save_SP:1;                     /* 27 */
7173     unsigned int Save_RP:1;                     /* 28 */
7174     unsigned int Save_MRP_in_frame:1;           /* 29 */
7175     unsigned int extn_ptr_defined:1;            /* 30 */
7176     unsigned int Cleanup_defined:1;             /* 31 */
7177
7178     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7179     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7180     unsigned int Large_frame:1;                 /* 2 */
7181     unsigned int Pseudo_SP_Set:1;               /* 3 */
7182     unsigned int reserved4:1;                   /* 4 */
7183     unsigned int Total_frame_size:27;           /* 5..31 */
7184   };
7185
7186 struct hppa_unw_aux_info
7187 {
7188   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7189   unsigned long table_len;              /* Length of unwind table.  */
7190   bfd_vma seg_base;                     /* Starting address of segment.  */
7191   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7192   unsigned long nsyms;                  /* Number of symbols.  */
7193   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7194   unsigned long nfuns;                  /* Number of entries in funtab.  */
7195   char * strtab;                        /* The string table.  */
7196   unsigned long strtab_size;            /* Size of string table.  */
7197 };
7198
7199 static void
7200 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7201 {
7202   struct hppa_unw_table_entry * tp;
7203   unsigned long j, nfuns;
7204
7205   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7206   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7207     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7208       aux->funtab[nfuns++] = aux->symtab[j];
7209   aux->nfuns = nfuns;
7210   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7211
7212   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7213     {
7214       bfd_vma offset;
7215       const char * procname;
7216
7217       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7218                                aux->strtab_size, tp->start, &procname,
7219                                &offset);
7220
7221       fputs ("\n<", stdout);
7222
7223       if (procname)
7224         {
7225           fputs (procname, stdout);
7226
7227           if (offset)
7228             printf ("+%lx", (unsigned long) offset);
7229         }
7230
7231       fputs (">: [", stdout);
7232       print_vma (tp->start.offset, PREFIX_HEX);
7233       fputc ('-', stdout);
7234       print_vma (tp->end.offset, PREFIX_HEX);
7235       printf ("]\n\t");
7236
7237 #define PF(_m) if (tp->_m) printf (#_m " ");
7238 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7239       PF(Cannot_unwind);
7240       PF(Millicode);
7241       PF(Millicode_save_sr0);
7242       /* PV(Region_description);  */
7243       PF(Entry_SR);
7244       PV(Entry_FR);
7245       PV(Entry_GR);
7246       PF(Args_stored);
7247       PF(Variable_Frame);
7248       PF(Separate_Package_Body);
7249       PF(Frame_Extension_Millicode);
7250       PF(Stack_Overflow_Check);
7251       PF(Two_Instruction_SP_Increment);
7252       PF(Ada_Region);
7253       PF(cxx_info);
7254       PF(cxx_try_catch);
7255       PF(sched_entry_seq);
7256       PF(Save_SP);
7257       PF(Save_RP);
7258       PF(Save_MRP_in_frame);
7259       PF(extn_ptr_defined);
7260       PF(Cleanup_defined);
7261       PF(MPE_XL_interrupt_marker);
7262       PF(HP_UX_interrupt_marker);
7263       PF(Large_frame);
7264       PF(Pseudo_SP_Set);
7265       PV(Total_frame_size);
7266 #undef PF
7267 #undef PV
7268     }
7269
7270   printf ("\n");
7271
7272   free (aux->funtab);
7273 }
7274
7275 static int
7276 slurp_hppa_unwind_table (FILE * file,
7277                          struct hppa_unw_aux_info * aux,
7278                          Elf_Internal_Shdr * sec)
7279 {
7280   unsigned long size, unw_ent_size, nentries, nrelas, i;
7281   Elf_Internal_Phdr * seg;
7282   struct hppa_unw_table_entry * tep;
7283   Elf_Internal_Shdr * relsec;
7284   Elf_Internal_Rela * rela;
7285   Elf_Internal_Rela * rp;
7286   unsigned char * table;
7287   unsigned char * tp;
7288   Elf_Internal_Sym * sym;
7289   const char * relname;
7290
7291   /* First, find the starting address of the segment that includes
7292      this section.  */
7293
7294   if (elf_header.e_phnum)
7295     {
7296       if (! get_program_headers (file))
7297         return 0;
7298
7299       for (seg = program_headers;
7300            seg < program_headers + elf_header.e_phnum;
7301            ++seg)
7302         {
7303           if (seg->p_type != PT_LOAD)
7304             continue;
7305
7306           if (sec->sh_addr >= seg->p_vaddr
7307               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7308             {
7309               aux->seg_base = seg->p_vaddr;
7310               break;
7311             }
7312         }
7313     }
7314
7315   /* Second, build the unwind table from the contents of the unwind
7316      section.  */
7317   size = sec->sh_size;
7318   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7319                                       _("unwind table"));
7320   if (!table)
7321     return 0;
7322
7323   unw_ent_size = 16;
7324   nentries = size / unw_ent_size;
7325   size = unw_ent_size * nentries;
7326
7327   tep = aux->table = (struct hppa_unw_table_entry *)
7328       xcmalloc (nentries, sizeof (aux->table[0]));
7329
7330   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7331     {
7332       unsigned int tmp1, tmp2;
7333
7334       tep->start.section = SHN_UNDEF;
7335       tep->end.section   = SHN_UNDEF;
7336
7337       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7338       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7339       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7340       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7341
7342       tep->start.offset += aux->seg_base;
7343       tep->end.offset   += aux->seg_base;
7344
7345       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7346       tep->Millicode = (tmp1 >> 30) & 0x1;
7347       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7348       tep->Region_description = (tmp1 >> 27) & 0x3;
7349       tep->reserved1 = (tmp1 >> 26) & 0x1;
7350       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7351       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7352       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7353       tep->Args_stored = (tmp1 >> 15) & 0x1;
7354       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7355       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7356       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7357       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7358       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7359       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7360       tep->cxx_info = (tmp1 >> 8) & 0x1;
7361       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7362       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7363       tep->reserved2 = (tmp1 >> 5) & 0x1;
7364       tep->Save_SP = (tmp1 >> 4) & 0x1;
7365       tep->Save_RP = (tmp1 >> 3) & 0x1;
7366       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7367       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7368       tep->Cleanup_defined = tmp1 & 0x1;
7369
7370       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7371       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7372       tep->Large_frame = (tmp2 >> 29) & 0x1;
7373       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7374       tep->reserved4 = (tmp2 >> 27) & 0x1;
7375       tep->Total_frame_size = tmp2 & 0x7ffffff;
7376     }
7377   free (table);
7378
7379   /* Third, apply any relocations to the unwind table.  */
7380   for (relsec = section_headers;
7381        relsec < section_headers + elf_header.e_shnum;
7382        ++relsec)
7383     {
7384       if (relsec->sh_type != SHT_RELA
7385           || relsec->sh_info >= elf_header.e_shnum
7386           || section_headers + relsec->sh_info != sec)
7387         continue;
7388
7389       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7390                               & rela, & nrelas))
7391         return 0;
7392
7393       for (rp = rela; rp < rela + nrelas; ++rp)
7394         {
7395           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7396           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7397
7398           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7399           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7400             {
7401               warn (_("Skipping unexpected relocation type %s\n"), relname);
7402               continue;
7403             }
7404
7405           i = rp->r_offset / unw_ent_size;
7406
7407           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7408             {
7409             case 0:
7410               aux->table[i].start.section = sym->st_shndx;
7411               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7412               break;
7413             case 1:
7414               aux->table[i].end.section   = sym->st_shndx;
7415               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7416               break;
7417             default:
7418               break;
7419             }
7420         }
7421
7422       free (rela);
7423     }
7424
7425   aux->table_len = nentries;
7426
7427   return 1;
7428 }
7429
7430 static void
7431 hppa_process_unwind (FILE * file)
7432 {
7433   struct hppa_unw_aux_info aux;
7434   Elf_Internal_Shdr * unwsec = NULL;
7435   Elf_Internal_Shdr * strsec;
7436   Elf_Internal_Shdr * sec;
7437   unsigned long i;
7438
7439   if (string_table == NULL)
7440     return;
7441
7442   memset (& aux, 0, sizeof (aux));
7443
7444   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7445     {
7446       if (sec->sh_type == SHT_SYMTAB
7447           && sec->sh_link < elf_header.e_shnum)
7448         {
7449           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7450
7451           strsec = section_headers + sec->sh_link;
7452           if (aux.strtab != NULL)
7453             {
7454               error (_("Multiple auxillary string tables encountered\n"));
7455               free (aux.strtab);
7456             }
7457           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7458                                           1, strsec->sh_size,
7459                                           _("string table"));
7460           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7461         }
7462       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7463         unwsec = sec;
7464     }
7465
7466   if (!unwsec)
7467     printf (_("\nThere are no unwind sections in this file.\n"));
7468
7469   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7470     {
7471       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7472         {
7473           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7474                   printable_section_name (sec),
7475                   (unsigned long) sec->sh_offset,
7476                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7477
7478           slurp_hppa_unwind_table (file, &aux, sec);
7479           if (aux.table_len > 0)
7480             dump_hppa_unwind (&aux);
7481
7482           if (aux.table)
7483             free ((char *) aux.table);
7484           aux.table = NULL;
7485         }
7486     }
7487
7488   if (aux.symtab)
7489     free (aux.symtab);
7490   if (aux.strtab)
7491     free ((char *) aux.strtab);
7492 }
7493
7494 struct arm_section
7495 {
7496   unsigned char *      data;            /* The unwind data.  */
7497   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7498   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7499   unsigned long        nrelas;          /* The number of relocations.  */
7500   unsigned int         rel_type;        /* REL or RELA ?  */
7501   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7502 };
7503
7504 struct arm_unw_aux_info
7505 {
7506   FILE *              file;             /* The file containing the unwind sections.  */
7507   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7508   unsigned long       nsyms;            /* Number of symbols.  */
7509   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7510   unsigned long       nfuns;            /* Number of these symbols.  */
7511   char *              strtab;           /* The file's string table.  */
7512   unsigned long       strtab_size;      /* Size of string table.  */
7513 };
7514
7515 static const char *
7516 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7517                         bfd_vma fn, struct absaddr addr)
7518 {
7519   const char *procname;
7520   bfd_vma sym_offset;
7521
7522   if (addr.section == SHN_UNDEF)
7523     addr.offset = fn;
7524
7525   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7526                            aux->strtab_size, addr, &procname,
7527                            &sym_offset);
7528
7529   print_vma (fn, PREFIX_HEX);
7530
7531   if (procname)
7532     {
7533       fputs (" <", stdout);
7534       fputs (procname, stdout);
7535
7536       if (sym_offset)
7537         printf ("+0x%lx", (unsigned long) sym_offset);
7538       fputc ('>', stdout);
7539     }
7540
7541   return procname;
7542 }
7543
7544 static void
7545 arm_free_section (struct arm_section *arm_sec)
7546 {
7547   if (arm_sec->data != NULL)
7548     free (arm_sec->data);
7549
7550   if (arm_sec->rela != NULL)
7551     free (arm_sec->rela);
7552 }
7553
7554 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7555       cached section and install SEC instead.
7556    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7557       and return its valued in * WORDP, relocating if necessary.
7558    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7559       relocation's offset in ADDR.
7560    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7561       into the string table of the symbol associated with the reloc.  If no
7562       reloc was applied store -1 there.
7563    5) Return TRUE upon success, FALSE otherwise.  */
7564
7565 static bfd_boolean
7566 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7567                          struct arm_section *       arm_sec,
7568                          Elf_Internal_Shdr *        sec,
7569                          bfd_vma                    word_offset,
7570                          unsigned int *             wordp,
7571                          struct absaddr *           addr,
7572                          bfd_vma *                  sym_name)
7573 {
7574   Elf_Internal_Rela *rp;
7575   Elf_Internal_Sym *sym;
7576   const char * relname;
7577   unsigned int word;
7578   bfd_boolean wrapped;
7579
7580   if (sec == NULL || arm_sec == NULL)
7581     return FALSE;
7582
7583   addr->section = SHN_UNDEF;
7584   addr->offset = 0;
7585
7586   if (sym_name != NULL)
7587     *sym_name = (bfd_vma) -1;
7588
7589   /* If necessary, update the section cache.  */
7590   if (sec != arm_sec->sec)
7591     {
7592       Elf_Internal_Shdr *relsec;
7593
7594       arm_free_section (arm_sec);
7595
7596       arm_sec->sec = sec;
7597       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7598                                 sec->sh_size, _("unwind data"));
7599       arm_sec->rela = NULL;
7600       arm_sec->nrelas = 0;
7601
7602       for (relsec = section_headers;
7603            relsec < section_headers + elf_header.e_shnum;
7604            ++relsec)
7605         {
7606           if (relsec->sh_info >= elf_header.e_shnum
7607               || section_headers + relsec->sh_info != sec
7608               /* PR 15745: Check the section type as well.  */
7609               || (relsec->sh_type != SHT_REL
7610                   && relsec->sh_type != SHT_RELA))
7611             continue;
7612
7613           arm_sec->rel_type = relsec->sh_type;
7614           if (relsec->sh_type == SHT_REL)
7615             {
7616               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7617                                      relsec->sh_size,
7618                                      & arm_sec->rela, & arm_sec->nrelas))
7619                 return FALSE;
7620             }
7621           else /* relsec->sh_type == SHT_RELA */
7622             {
7623               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7624                                       relsec->sh_size,
7625                                       & arm_sec->rela, & arm_sec->nrelas))
7626                 return FALSE;
7627             }
7628           break;
7629         }
7630
7631       arm_sec->next_rela = arm_sec->rela;
7632     }
7633
7634   /* If there is no unwind data we can do nothing.  */
7635   if (arm_sec->data == NULL)
7636     return FALSE;
7637
7638   /* If the offset is invalid then fail.  */
7639   if (word_offset > (sec->sh_size - 4)
7640       /* PR 18879 */
7641       || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7642       || ((bfd_signed_vma) word_offset) < 0)
7643     return FALSE;
7644
7645   /* Get the word at the required offset.  */
7646   word = byte_get (arm_sec->data + word_offset, 4);
7647
7648   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7649   if (arm_sec->rela == NULL)
7650     {
7651       * wordp = word;
7652       return TRUE;
7653     }
7654
7655   /* Look through the relocs to find the one that applies to the provided offset.  */
7656   wrapped = FALSE;
7657   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7658     {
7659       bfd_vma prelval, offset;
7660
7661       if (rp->r_offset > word_offset && !wrapped)
7662         {
7663           rp = arm_sec->rela;
7664           wrapped = TRUE;
7665         }
7666       if (rp->r_offset > word_offset)
7667         break;
7668
7669       if (rp->r_offset & 3)
7670         {
7671           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7672                 (unsigned long) rp->r_offset);
7673           continue;
7674         }
7675
7676       if (rp->r_offset < word_offset)
7677         continue;
7678
7679       /* PR 17531: file: 027-161405-0.004  */
7680       if (aux->symtab == NULL)
7681         continue;
7682
7683       if (arm_sec->rel_type == SHT_REL)
7684         {
7685           offset = word & 0x7fffffff;
7686           if (offset & 0x40000000)
7687             offset |= ~ (bfd_vma) 0x7fffffff;
7688         }
7689       else if (arm_sec->rel_type == SHT_RELA)
7690         offset = rp->r_addend;
7691       else
7692         {
7693           error (_("Unknown section relocation type %d encountered\n"),
7694                  arm_sec->rel_type);
7695           break;
7696         }
7697
7698       /* PR 17531 file: 027-1241568-0.004.  */
7699       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7700         {
7701           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7702                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7703           break;
7704         }
7705
7706       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7707       offset += sym->st_value;
7708       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7709
7710       /* Check that we are processing the expected reloc type.  */
7711       if (elf_header.e_machine == EM_ARM)
7712         {
7713           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7714           if (relname == NULL)
7715             {
7716               warn (_("Skipping unknown ARM relocation type: %d\n"),
7717                     (int) ELF32_R_TYPE (rp->r_info));
7718               continue;
7719             }
7720
7721           if (streq (relname, "R_ARM_NONE"))
7722               continue;
7723
7724           if (! streq (relname, "R_ARM_PREL31"))
7725             {
7726               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7727               continue;
7728             }
7729         }
7730       else if (elf_header.e_machine == EM_TI_C6000)
7731         {
7732           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7733           if (relname == NULL)
7734             {
7735               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7736                     (int) ELF32_R_TYPE (rp->r_info));
7737               continue;
7738             }
7739
7740           if (streq (relname, "R_C6000_NONE"))
7741             continue;
7742
7743           if (! streq (relname, "R_C6000_PREL31"))
7744             {
7745               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7746               continue;
7747             }
7748
7749           prelval >>= 1;
7750         }
7751       else
7752         {
7753           /* This function currently only supports ARM and TI unwinders.  */
7754           warn (_("Only TI and ARM unwinders are currently supported\n"));
7755           break;
7756         }
7757
7758       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7759       addr->section = sym->st_shndx;
7760       addr->offset = offset;
7761
7762       if (sym_name)
7763         * sym_name = sym->st_name;
7764       break;
7765     }
7766
7767   *wordp = word;
7768   arm_sec->next_rela = rp;
7769
7770   return TRUE;
7771 }
7772
7773 static const char *tic6x_unwind_regnames[16] =
7774 {
7775   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7776   "A14", "A13", "A12", "A11", "A10",
7777   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7778 };
7779
7780 static void
7781 decode_tic6x_unwind_regmask (unsigned int mask)
7782 {
7783   int i;
7784
7785   for (i = 12; mask; mask >>= 1, i--)
7786     {
7787       if (mask & 1)
7788         {
7789           fputs (tic6x_unwind_regnames[i], stdout);
7790           if (mask > 1)
7791             fputs (", ", stdout);
7792         }
7793     }
7794 }
7795
7796 #define ADVANCE                                                 \
7797   if (remaining == 0 && more_words)                             \
7798     {                                                           \
7799       data_offset += 4;                                         \
7800       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7801                                      data_offset, & word, & addr, NULL))        \
7802         return;                                                 \
7803       remaining = 4;                                            \
7804       more_words--;                                             \
7805     }                                                           \
7806
7807 #define GET_OP(OP)                      \
7808   ADVANCE;                              \
7809   if (remaining)                        \
7810     {                                   \
7811       remaining--;                      \
7812       (OP) = word >> 24;                \
7813       word <<= 8;                       \
7814     }                                   \
7815   else                                  \
7816     {                                   \
7817       printf (_("[Truncated opcode]\n"));       \
7818       return;                           \
7819     }                                   \
7820   printf ("0x%02x ", OP)
7821
7822 static void
7823 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7824                             unsigned int               word,
7825                             unsigned int               remaining,
7826                             unsigned int               more_words,
7827                             bfd_vma                    data_offset,
7828                             Elf_Internal_Shdr *        data_sec,
7829                             struct arm_section *       data_arm_sec)
7830 {
7831   struct absaddr addr;
7832
7833   /* Decode the unwinding instructions.  */
7834   while (1)
7835     {
7836       unsigned int op, op2;
7837
7838       ADVANCE;
7839       if (remaining == 0)
7840         break;
7841       remaining--;
7842       op = word >> 24;
7843       word <<= 8;
7844
7845       printf ("  0x%02x ", op);
7846
7847       if ((op & 0xc0) == 0x00)
7848         {
7849           int offset = ((op & 0x3f) << 2) + 4;
7850
7851           printf ("     vsp = vsp + %d", offset);
7852         }
7853       else if ((op & 0xc0) == 0x40)
7854         {
7855           int offset = ((op & 0x3f) << 2) + 4;
7856
7857           printf ("     vsp = vsp - %d", offset);
7858         }
7859       else if ((op & 0xf0) == 0x80)
7860         {
7861           GET_OP (op2);
7862           if (op == 0x80 && op2 == 0)
7863             printf (_("Refuse to unwind"));
7864           else
7865             {
7866               unsigned int mask = ((op & 0x0f) << 8) | op2;
7867               int first = 1;
7868               int i;
7869
7870               printf ("pop {");
7871               for (i = 0; i < 12; i++)
7872                 if (mask & (1 << i))
7873                   {
7874                     if (first)
7875                       first = 0;
7876                     else
7877                       printf (", ");
7878                     printf ("r%d", 4 + i);
7879                   }
7880               printf ("}");
7881             }
7882         }
7883       else if ((op & 0xf0) == 0x90)
7884         {
7885           if (op == 0x9d || op == 0x9f)
7886             printf (_("     [Reserved]"));
7887           else
7888             printf ("     vsp = r%d", op & 0x0f);
7889         }
7890       else if ((op & 0xf0) == 0xa0)
7891         {
7892           int end = 4 + (op & 0x07);
7893           int first = 1;
7894           int i;
7895
7896           printf ("     pop {");
7897           for (i = 4; i <= end; i++)
7898             {
7899               if (first)
7900                 first = 0;
7901               else
7902                 printf (", ");
7903               printf ("r%d", i);
7904             }
7905           if (op & 0x08)
7906             {
7907               if (!first)
7908                 printf (", ");
7909               printf ("r14");
7910             }
7911           printf ("}");
7912         }
7913       else if (op == 0xb0)
7914         printf (_("     finish"));
7915       else if (op == 0xb1)
7916         {
7917           GET_OP (op2);
7918           if (op2 == 0 || (op2 & 0xf0) != 0)
7919             printf (_("[Spare]"));
7920           else
7921             {
7922               unsigned int mask = op2 & 0x0f;
7923               int first = 1;
7924               int i;
7925
7926               printf ("pop {");
7927               for (i = 0; i < 12; i++)
7928                 if (mask & (1 << i))
7929                   {
7930                     if (first)
7931                       first = 0;
7932                     else
7933                       printf (", ");
7934                     printf ("r%d", i);
7935                   }
7936               printf ("}");
7937             }
7938         }
7939       else if (op == 0xb2)
7940         {
7941           unsigned char buf[9];
7942           unsigned int i, len;
7943           unsigned long offset;
7944
7945           for (i = 0; i < sizeof (buf); i++)
7946             {
7947               GET_OP (buf[i]);
7948               if ((buf[i] & 0x80) == 0)
7949                 break;
7950             }
7951           if (i == sizeof (buf))
7952             printf (_("corrupt change to vsp"));
7953           else
7954             {
7955               offset = read_uleb128 (buf, &len, buf + i + 1);
7956               assert (len == i + 1);
7957               offset = offset * 4 + 0x204;
7958               printf ("vsp = vsp + %ld", offset);
7959             }
7960         }
7961       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7962         {
7963           unsigned int first, last;
7964
7965           GET_OP (op2);
7966           first = op2 >> 4;
7967           last = op2 & 0x0f;
7968           if (op == 0xc8)
7969             first = first + 16;
7970           printf ("pop {D%d", first);
7971           if (last)
7972             printf ("-D%d", first + last);
7973           printf ("}");
7974         }
7975       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7976         {
7977           unsigned int count = op & 0x07;
7978
7979           printf ("pop {D8");
7980           if (count)
7981             printf ("-D%d", 8 + count);
7982           printf ("}");
7983         }
7984       else if (op >= 0xc0 && op <= 0xc5)
7985         {
7986           unsigned int count = op & 0x07;
7987
7988           printf ("     pop {wR10");
7989           if (count)
7990             printf ("-wR%d", 10 + count);
7991           printf ("}");
7992         }
7993       else if (op == 0xc6)
7994         {
7995           unsigned int first, last;
7996
7997           GET_OP (op2);
7998           first = op2 >> 4;
7999           last = op2 & 0x0f;
8000           printf ("pop {wR%d", first);
8001           if (last)
8002             printf ("-wR%d", first + last);
8003           printf ("}");
8004         }
8005       else if (op == 0xc7)
8006         {
8007           GET_OP (op2);
8008           if (op2 == 0 || (op2 & 0xf0) != 0)
8009             printf (_("[Spare]"));
8010           else
8011             {
8012               unsigned int mask = op2 & 0x0f;
8013               int first = 1;
8014               int i;
8015
8016               printf ("pop {");
8017               for (i = 0; i < 4; i++)
8018                 if (mask & (1 << i))
8019                   {
8020                     if (first)
8021                       first = 0;
8022                     else
8023                       printf (", ");
8024                     printf ("wCGR%d", i);
8025                   }
8026               printf ("}");
8027             }
8028         }
8029       else
8030         printf (_("     [unsupported opcode]"));
8031       printf ("\n");
8032     }
8033 }
8034
8035 static void
8036 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8037                               unsigned int               word,
8038                               unsigned int               remaining,
8039                               unsigned int               more_words,
8040                               bfd_vma                    data_offset,
8041                               Elf_Internal_Shdr *        data_sec,
8042                               struct arm_section *       data_arm_sec)
8043 {
8044   struct absaddr addr;
8045
8046   /* Decode the unwinding instructions.  */
8047   while (1)
8048     {
8049       unsigned int op, op2;
8050
8051       ADVANCE;
8052       if (remaining == 0)
8053         break;
8054       remaining--;
8055       op = word >> 24;
8056       word <<= 8;
8057
8058       printf ("  0x%02x ", op);
8059
8060       if ((op & 0xc0) == 0x00)
8061         {
8062           int offset = ((op & 0x3f) << 3) + 8;
8063           printf ("     sp = sp + %d", offset);
8064         }
8065       else if ((op & 0xc0) == 0x80)
8066         {
8067           GET_OP (op2);
8068           if (op == 0x80 && op2 == 0)
8069             printf (_("Refuse to unwind"));
8070           else
8071             {
8072               unsigned int mask = ((op & 0x1f) << 8) | op2;
8073               if (op & 0x20)
8074                 printf ("pop compact {");
8075               else
8076                 printf ("pop {");
8077
8078               decode_tic6x_unwind_regmask (mask);
8079               printf("}");
8080             }
8081         }
8082       else if ((op & 0xf0) == 0xc0)
8083         {
8084           unsigned int reg;
8085           unsigned int nregs;
8086           unsigned int i;
8087           const char *name;
8088           struct
8089           {
8090               unsigned int offset;
8091               unsigned int reg;
8092           } regpos[16];
8093
8094           /* Scan entire instruction first so that GET_OP output is not
8095              interleaved with disassembly.  */
8096           nregs = 0;
8097           for (i = 0; nregs < (op & 0xf); i++)
8098             {
8099               GET_OP (op2);
8100               reg = op2 >> 4;
8101               if (reg != 0xf)
8102                 {
8103                   regpos[nregs].offset = i * 2;
8104                   regpos[nregs].reg = reg;
8105                   nregs++;
8106                 }
8107
8108               reg = op2 & 0xf;
8109               if (reg != 0xf)
8110                 {
8111                   regpos[nregs].offset = i * 2 + 1;
8112                   regpos[nregs].reg = reg;
8113                   nregs++;
8114                 }
8115             }
8116
8117           printf (_("pop frame {"));
8118           reg = nregs - 1;
8119           for (i = i * 2; i > 0; i--)
8120             {
8121               if (regpos[reg].offset == i - 1)
8122                 {
8123                   name = tic6x_unwind_regnames[regpos[reg].reg];
8124                   if (reg > 0)
8125                     reg--;
8126                 }
8127               else
8128                 name = _("[pad]");
8129
8130               fputs (name, stdout);
8131               if (i > 1)
8132                 printf (", ");
8133             }
8134
8135           printf ("}");
8136         }
8137       else if (op == 0xd0)
8138         printf ("     MOV FP, SP");
8139       else if (op == 0xd1)
8140         printf ("     __c6xabi_pop_rts");
8141       else if (op == 0xd2)
8142         {
8143           unsigned char buf[9];
8144           unsigned int i, len;
8145           unsigned long offset;
8146
8147           for (i = 0; i < sizeof (buf); i++)
8148             {
8149               GET_OP (buf[i]);
8150               if ((buf[i] & 0x80) == 0)
8151                 break;
8152             }
8153           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8154           if (i == sizeof (buf))
8155             {
8156               printf ("<corrupt sp adjust>\n");
8157               warn (_("Corrupt stack pointer adjustment detected\n"));
8158               return;
8159             }
8160
8161           offset = read_uleb128 (buf, &len, buf + i + 1);
8162           assert (len == i + 1);
8163           offset = offset * 8 + 0x408;
8164           printf (_("sp = sp + %ld"), offset);
8165         }
8166       else if ((op & 0xf0) == 0xe0)
8167         {
8168           if ((op & 0x0f) == 7)
8169             printf ("     RETURN");
8170           else
8171             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8172         }
8173       else
8174         {
8175           printf (_("     [unsupported opcode]"));
8176         }
8177       putchar ('\n');
8178     }
8179 }
8180
8181 static bfd_vma
8182 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8183 {
8184   bfd_vma offset;
8185
8186   offset = word & 0x7fffffff;
8187   if (offset & 0x40000000)
8188     offset |= ~ (bfd_vma) 0x7fffffff;
8189
8190   if (elf_header.e_machine == EM_TI_C6000)
8191     offset <<= 1;
8192
8193   return offset + where;
8194 }
8195
8196 static void
8197 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8198                    unsigned int               word,
8199                    unsigned int               remaining,
8200                    bfd_vma                    data_offset,
8201                    Elf_Internal_Shdr *        data_sec,
8202                    struct arm_section *       data_arm_sec)
8203 {
8204   int per_index;
8205   unsigned int more_words = 0;
8206   struct absaddr addr;
8207   bfd_vma sym_name = (bfd_vma) -1;
8208
8209   if (remaining == 0)
8210     {
8211       /* Fetch the first word.
8212          Note - when decoding an object file the address extracted
8213          here will always be 0.  So we also pass in the sym_name
8214          parameter so that we can find the symbol associated with
8215          the personality routine.  */
8216       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8217                                      & word, & addr, & sym_name))
8218         return;
8219
8220       remaining = 4;
8221     }
8222
8223   if ((word & 0x80000000) == 0)
8224     {
8225       /* Expand prel31 for personality routine.  */
8226       bfd_vma fn;
8227       const char *procname;
8228
8229       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8230       printf (_("  Personality routine: "));
8231       if (fn == 0
8232           && addr.section == SHN_UNDEF && addr.offset == 0
8233           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8234         {
8235           procname = aux->strtab + sym_name;
8236           print_vma (fn, PREFIX_HEX);
8237           if (procname)
8238             {
8239               fputs (" <", stdout);
8240               fputs (procname, stdout);
8241               fputc ('>', stdout);
8242             }
8243         }
8244       else
8245         procname = arm_print_vma_and_name (aux, fn, addr);
8246       fputc ('\n', stdout);
8247
8248       /* The GCC personality routines use the standard compact
8249          encoding, starting with one byte giving the number of
8250          words.  */
8251       if (procname != NULL
8252           && (const_strneq (procname, "__gcc_personality_v0")
8253               || const_strneq (procname, "__gxx_personality_v0")
8254               || const_strneq (procname, "__gcj_personality_v0")
8255               || const_strneq (procname, "__gnu_objc_personality_v0")))
8256         {
8257           remaining = 0;
8258           more_words = 1;
8259           ADVANCE;
8260           if (!remaining)
8261             {
8262               printf (_("  [Truncated data]\n"));
8263               return;
8264             }
8265           more_words = word >> 24;
8266           word <<= 8;
8267           remaining--;
8268           per_index = -1;
8269         }
8270       else
8271         return;
8272     }
8273   else
8274     {
8275       /* ARM EHABI Section 6.3:
8276
8277          An exception-handling table entry for the compact model looks like:
8278
8279            31 30-28 27-24 23-0
8280            -- ----- ----- ----
8281             1   0   index Data for personalityRoutine[index]    */
8282
8283       if (elf_header.e_machine == EM_ARM
8284           && (word & 0x70000000))
8285         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8286
8287       per_index = (word >> 24) & 0x7f;
8288       printf (_("  Compact model index: %d\n"), per_index);
8289       if (per_index == 0)
8290         {
8291           more_words = 0;
8292           word <<= 8;
8293           remaining--;
8294         }
8295       else if (per_index < 3)
8296         {
8297           more_words = (word >> 16) & 0xff;
8298           word <<= 16;
8299           remaining -= 2;
8300         }
8301     }
8302
8303   switch (elf_header.e_machine)
8304     {
8305     case EM_ARM:
8306       if (per_index < 3)
8307         {
8308           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8309                                       data_offset, data_sec, data_arm_sec);
8310         }
8311       else
8312         {
8313           warn (_("Unknown ARM compact model index encountered\n"));
8314           printf (_("  [reserved]\n"));
8315         }
8316       break;
8317
8318     case EM_TI_C6000:
8319       if (per_index < 3)
8320         {
8321           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8322                                         data_offset, data_sec, data_arm_sec);
8323         }
8324       else if (per_index < 5)
8325         {
8326           if (((word >> 17) & 0x7f) == 0x7f)
8327             printf (_("  Restore stack from frame pointer\n"));
8328           else
8329             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8330           printf (_("  Registers restored: "));
8331           if (per_index == 4)
8332             printf (" (compact) ");
8333           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8334           putchar ('\n');
8335           printf (_("  Return register: %s\n"),
8336                   tic6x_unwind_regnames[word & 0xf]);
8337         }
8338       else
8339         printf (_("  [reserved (%d)]\n"), per_index);
8340       break;
8341
8342     default:
8343       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8344              elf_header.e_machine);
8345     }
8346
8347   /* Decode the descriptors.  Not implemented.  */
8348 }
8349
8350 static void
8351 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8352 {
8353   struct arm_section exidx_arm_sec, extab_arm_sec;
8354   unsigned int i, exidx_len;
8355   unsigned long j, nfuns;
8356
8357   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8358   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8359   exidx_len = exidx_sec->sh_size / 8;
8360
8361   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8362   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8363     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8364       aux->funtab[nfuns++] = aux->symtab[j];
8365   aux->nfuns = nfuns;
8366   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8367
8368   for (i = 0; i < exidx_len; i++)
8369     {
8370       unsigned int exidx_fn, exidx_entry;
8371       struct absaddr fn_addr, entry_addr;
8372       bfd_vma fn;
8373
8374       fputc ('\n', stdout);
8375
8376       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8377                                      8 * i, & exidx_fn, & fn_addr, NULL)
8378           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8379                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8380         {
8381           free (aux->funtab);
8382           arm_free_section (& exidx_arm_sec);
8383           arm_free_section (& extab_arm_sec);
8384           return;
8385         }
8386
8387       /* ARM EHABI, Section 5:
8388          An index table entry consists of 2 words.
8389          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8390       if (exidx_fn & 0x80000000)
8391         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8392
8393       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8394
8395       arm_print_vma_and_name (aux, fn, fn_addr);
8396       fputs (": ", stdout);
8397
8398       if (exidx_entry == 1)
8399         {
8400           print_vma (exidx_entry, PREFIX_HEX);
8401           fputs (" [cantunwind]\n", stdout);
8402         }
8403       else if (exidx_entry & 0x80000000)
8404         {
8405           print_vma (exidx_entry, PREFIX_HEX);
8406           fputc ('\n', stdout);
8407           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8408         }
8409       else
8410         {
8411           bfd_vma table, table_offset = 0;
8412           Elf_Internal_Shdr *table_sec;
8413
8414           fputs ("@", stdout);
8415           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8416           print_vma (table, PREFIX_HEX);
8417           printf ("\n");
8418
8419           /* Locate the matching .ARM.extab.  */
8420           if (entry_addr.section != SHN_UNDEF
8421               && entry_addr.section < elf_header.e_shnum)
8422             {
8423               table_sec = section_headers + entry_addr.section;
8424               table_offset = entry_addr.offset;
8425               /* PR 18879 */
8426               if (table_offset > table_sec->sh_size
8427                   || ((bfd_signed_vma) table_offset) < 0)
8428                 {
8429                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8430                         (unsigned long) table_offset,
8431                         printable_section_name (table_sec));
8432                   continue;
8433                 }
8434             }
8435           else
8436             {
8437               table_sec = find_section_by_address (table);
8438               if (table_sec != NULL)
8439                 table_offset = table - table_sec->sh_addr;
8440             }
8441           if (table_sec == NULL)
8442             {
8443               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8444                     (unsigned long) table);
8445               continue;
8446             }
8447           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8448                              &extab_arm_sec);
8449         }
8450     }
8451
8452   printf ("\n");
8453
8454   free (aux->funtab);
8455   arm_free_section (&exidx_arm_sec);
8456   arm_free_section (&extab_arm_sec);
8457 }
8458
8459 /* Used for both ARM and C6X unwinding tables.  */
8460
8461 static void
8462 arm_process_unwind (FILE *file)
8463 {
8464   struct arm_unw_aux_info aux;
8465   Elf_Internal_Shdr *unwsec = NULL;
8466   Elf_Internal_Shdr *strsec;
8467   Elf_Internal_Shdr *sec;
8468   unsigned long i;
8469   unsigned int sec_type;
8470
8471   switch (elf_header.e_machine)
8472     {
8473     case EM_ARM:
8474       sec_type = SHT_ARM_EXIDX;
8475       break;
8476
8477     case EM_TI_C6000:
8478       sec_type = SHT_C6000_UNWIND;
8479       break;
8480
8481     default:
8482       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8483              elf_header.e_machine);
8484       return;
8485     }
8486
8487   if (string_table == NULL)
8488     return;
8489
8490   memset (& aux, 0, sizeof (aux));
8491   aux.file = file;
8492
8493   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8494     {
8495       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8496         {
8497           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8498
8499           strsec = section_headers + sec->sh_link;
8500
8501           /* PR binutils/17531 file: 011-12666-0.004.  */
8502           if (aux.strtab != NULL)
8503             {
8504               error (_("Multiple string tables found in file.\n"));
8505               free (aux.strtab);
8506             }
8507           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8508                                  1, strsec->sh_size, _("string table"));
8509           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8510         }
8511       else if (sec->sh_type == sec_type)
8512         unwsec = sec;
8513     }
8514
8515   if (unwsec == NULL)
8516     printf (_("\nThere are no unwind sections in this file.\n"));
8517   else
8518     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8519       {
8520         if (sec->sh_type == sec_type)
8521           {
8522             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8523                     printable_section_name (sec),
8524                     (unsigned long) sec->sh_offset,
8525                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8526
8527             dump_arm_unwind (&aux, sec);
8528           }
8529       }
8530
8531   if (aux.symtab)
8532     free (aux.symtab);
8533   if (aux.strtab)
8534     free ((char *) aux.strtab);
8535 }
8536
8537 static void
8538 process_unwind (FILE * file)
8539 {
8540   struct unwind_handler
8541   {
8542     int machtype;
8543     void (* handler)(FILE *);
8544   } handlers[] =
8545   {
8546     { EM_ARM, arm_process_unwind },
8547     { EM_IA_64, ia64_process_unwind },
8548     { EM_PARISC, hppa_process_unwind },
8549     { EM_TI_C6000, arm_process_unwind },
8550     { 0, 0 }
8551   };
8552   int i;
8553
8554   if (!do_unwind)
8555     return;
8556
8557   for (i = 0; handlers[i].handler != NULL; i++)
8558     if (elf_header.e_machine == handlers[i].machtype)
8559       {
8560         handlers[i].handler (file);
8561         return;
8562       }
8563
8564   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8565           get_machine_name (elf_header.e_machine));
8566 }
8567
8568 static void
8569 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8570 {
8571   switch (entry->d_tag)
8572     {
8573     case DT_MIPS_FLAGS:
8574       if (entry->d_un.d_val == 0)
8575         printf (_("NONE"));
8576       else
8577         {
8578           static const char * opts[] =
8579           {
8580             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8581             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8582             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8583             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8584             "RLD_ORDER_SAFE"
8585           };
8586           unsigned int cnt;
8587           int first = 1;
8588
8589           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8590             if (entry->d_un.d_val & (1 << cnt))
8591               {
8592                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8593                 first = 0;
8594               }
8595         }
8596       break;
8597
8598     case DT_MIPS_IVERSION:
8599       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8600         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8601       else
8602         {
8603           char buf[40];
8604           sprintf_vma (buf, entry->d_un.d_ptr);
8605           /* Note: coded this way so that there is a single string for translation.  */
8606           printf (_("<corrupt: %s>"), buf);
8607         }
8608       break;
8609
8610     case DT_MIPS_TIME_STAMP:
8611       {
8612         char timebuf[20];
8613         struct tm * tmp;
8614         time_t atime = entry->d_un.d_val;
8615
8616         tmp = gmtime (&atime);
8617         /* PR 17531: file: 6accc532.  */
8618         if (tmp == NULL)
8619           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8620         else
8621           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8622                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8623                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8624         printf (_("Time Stamp: %s"), timebuf);
8625       }
8626       break;
8627
8628     case DT_MIPS_RLD_VERSION:
8629     case DT_MIPS_LOCAL_GOTNO:
8630     case DT_MIPS_CONFLICTNO:
8631     case DT_MIPS_LIBLISTNO:
8632     case DT_MIPS_SYMTABNO:
8633     case DT_MIPS_UNREFEXTNO:
8634     case DT_MIPS_HIPAGENO:
8635     case DT_MIPS_DELTA_CLASS_NO:
8636     case DT_MIPS_DELTA_INSTANCE_NO:
8637     case DT_MIPS_DELTA_RELOC_NO:
8638     case DT_MIPS_DELTA_SYM_NO:
8639     case DT_MIPS_DELTA_CLASSSYM_NO:
8640     case DT_MIPS_COMPACT_SIZE:
8641       print_vma (entry->d_un.d_ptr, DEC);
8642       break;
8643
8644     default:
8645       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8646     }
8647     putchar ('\n');
8648 }
8649
8650 static void
8651 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8652 {
8653   switch (entry->d_tag)
8654     {
8655     case DT_HP_DLD_FLAGS:
8656       {
8657         static struct
8658         {
8659           long int bit;
8660           const char * str;
8661         }
8662         flags[] =
8663         {
8664           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8665           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8666           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8667           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8668           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8669           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8670           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8671           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8672           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8673           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8674           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8675           { DT_HP_GST, "HP_GST" },
8676           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8677           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8678           { DT_HP_NODELETE, "HP_NODELETE" },
8679           { DT_HP_GROUP, "HP_GROUP" },
8680           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8681         };
8682         int first = 1;
8683         size_t cnt;
8684         bfd_vma val = entry->d_un.d_val;
8685
8686         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8687           if (val & flags[cnt].bit)
8688             {
8689               if (! first)
8690                 putchar (' ');
8691               fputs (flags[cnt].str, stdout);
8692               first = 0;
8693               val ^= flags[cnt].bit;
8694             }
8695
8696         if (val != 0 || first)
8697           {
8698             if (! first)
8699               putchar (' ');
8700             print_vma (val, HEX);
8701           }
8702       }
8703       break;
8704
8705     default:
8706       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8707       break;
8708     }
8709   putchar ('\n');
8710 }
8711
8712 #ifdef BFD64
8713
8714 /* VMS vs Unix time offset and factor.  */
8715
8716 #define VMS_EPOCH_OFFSET 35067168000000000LL
8717 #define VMS_GRANULARITY_FACTOR 10000000
8718
8719 /* Display a VMS time in a human readable format.  */
8720
8721 static void
8722 print_vms_time (bfd_int64_t vmstime)
8723 {
8724   struct tm *tm;
8725   time_t unxtime;
8726
8727   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8728   tm = gmtime (&unxtime);
8729   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8730           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8731           tm->tm_hour, tm->tm_min, tm->tm_sec);
8732 }
8733 #endif /* BFD64 */
8734
8735 static void
8736 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8737 {
8738   switch (entry->d_tag)
8739     {
8740     case DT_IA_64_PLT_RESERVE:
8741       /* First 3 slots reserved.  */
8742       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8743       printf (" -- ");
8744       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8745       break;
8746
8747     case DT_IA_64_VMS_LINKTIME:
8748 #ifdef BFD64
8749       print_vms_time (entry->d_un.d_val);
8750 #endif
8751       break;
8752
8753     case DT_IA_64_VMS_LNKFLAGS:
8754       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8755       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8756         printf (" CALL_DEBUG");
8757       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8758         printf (" NOP0BUFS");
8759       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8760         printf (" P0IMAGE");
8761       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8762         printf (" MKTHREADS");
8763       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8764         printf (" UPCALLS");
8765       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8766         printf (" IMGSTA");
8767       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8768         printf (" INITIALIZE");
8769       if (entry->d_un.d_val & VMS_LF_MAIN)
8770         printf (" MAIN");
8771       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8772         printf (" EXE_INIT");
8773       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8774         printf (" TBK_IN_IMG");
8775       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8776         printf (" DBG_IN_IMG");
8777       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8778         printf (" TBK_IN_DSF");
8779       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8780         printf (" DBG_IN_DSF");
8781       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8782         printf (" SIGNATURES");
8783       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8784         printf (" REL_SEG_OFF");
8785       break;
8786
8787     default:
8788       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8789       break;
8790     }
8791   putchar ('\n');
8792 }
8793
8794 static int
8795 get_32bit_dynamic_section (FILE * file)
8796 {
8797   Elf32_External_Dyn * edyn;
8798   Elf32_External_Dyn * ext;
8799   Elf_Internal_Dyn * entry;
8800
8801   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8802                                           dynamic_size, _("dynamic section"));
8803   if (!edyn)
8804     return 0;
8805
8806   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8807      might not have the luxury of section headers.  Look for the DT_NULL
8808      terminator to determine the number of entries.  */
8809   for (ext = edyn, dynamic_nent = 0;
8810        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8811        ext++)
8812     {
8813       dynamic_nent++;
8814       if (BYTE_GET (ext->d_tag) == DT_NULL)
8815         break;
8816     }
8817
8818   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8819                                                   sizeof (* entry));
8820   if (dynamic_section == NULL)
8821     {
8822       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8823              (unsigned long) dynamic_nent);
8824       free (edyn);
8825       return 0;
8826     }
8827
8828   for (ext = edyn, entry = dynamic_section;
8829        entry < dynamic_section + dynamic_nent;
8830        ext++, entry++)
8831     {
8832       entry->d_tag      = BYTE_GET (ext->d_tag);
8833       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8834     }
8835
8836   free (edyn);
8837
8838   return 1;
8839 }
8840
8841 static int
8842 get_64bit_dynamic_section (FILE * file)
8843 {
8844   Elf64_External_Dyn * edyn;
8845   Elf64_External_Dyn * ext;
8846   Elf_Internal_Dyn * entry;
8847
8848   /* Read in the data.  */
8849   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8850                                           dynamic_size, _("dynamic section"));
8851   if (!edyn)
8852     return 0;
8853
8854   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8855      might not have the luxury of section headers.  Look for the DT_NULL
8856      terminator to determine the number of entries.  */
8857   for (ext = edyn, dynamic_nent = 0;
8858        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
8859        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8860        ext++)
8861     {
8862       dynamic_nent++;
8863       if (BYTE_GET (ext->d_tag) == DT_NULL)
8864         break;
8865     }
8866
8867   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8868                                                   sizeof (* entry));
8869   if (dynamic_section == NULL)
8870     {
8871       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8872              (unsigned long) dynamic_nent);
8873       free (edyn);
8874       return 0;
8875     }
8876
8877   /* Convert from external to internal formats.  */
8878   for (ext = edyn, entry = dynamic_section;
8879        entry < dynamic_section + dynamic_nent;
8880        ext++, entry++)
8881     {
8882       entry->d_tag      = BYTE_GET (ext->d_tag);
8883       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8884     }
8885
8886   free (edyn);
8887
8888   return 1;
8889 }
8890
8891 static void
8892 print_dynamic_flags (bfd_vma flags)
8893 {
8894   int first = 1;
8895
8896   while (flags)
8897     {
8898       bfd_vma flag;
8899
8900       flag = flags & - flags;
8901       flags &= ~ flag;
8902
8903       if (first)
8904         first = 0;
8905       else
8906         putc (' ', stdout);
8907
8908       switch (flag)
8909         {
8910         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8911         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8912         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8913         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8914         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8915         default:                fputs (_("unknown"), stdout); break;
8916         }
8917     }
8918   puts ("");
8919 }
8920
8921 /* Parse and display the contents of the dynamic section.  */
8922
8923 static int
8924 process_dynamic_section (FILE * file)
8925 {
8926   Elf_Internal_Dyn * entry;
8927
8928   if (dynamic_size == 0)
8929     {
8930       if (do_dynamic)
8931         printf (_("\nThere is no dynamic section in this file.\n"));
8932
8933       return 1;
8934     }
8935
8936   if (is_32bit_elf)
8937     {
8938       if (! get_32bit_dynamic_section (file))
8939         return 0;
8940     }
8941   else if (! get_64bit_dynamic_section (file))
8942     return 0;
8943
8944   /* Find the appropriate symbol table.  */
8945   if (dynamic_symbols == NULL)
8946     {
8947       for (entry = dynamic_section;
8948            entry < dynamic_section + dynamic_nent;
8949            ++entry)
8950         {
8951           Elf_Internal_Shdr section;
8952
8953           if (entry->d_tag != DT_SYMTAB)
8954             continue;
8955
8956           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8957
8958           /* Since we do not know how big the symbol table is,
8959              we default to reading in the entire file (!) and
8960              processing that.  This is overkill, I know, but it
8961              should work.  */
8962           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8963
8964           if (archive_file_offset != 0)
8965             section.sh_size = archive_file_size - section.sh_offset;
8966           else
8967             {
8968               if (fseek (file, 0, SEEK_END))
8969                 error (_("Unable to seek to end of file!\n"));
8970
8971               section.sh_size = ftell (file) - section.sh_offset;
8972             }
8973
8974           if (is_32bit_elf)
8975             section.sh_entsize = sizeof (Elf32_External_Sym);
8976           else
8977             section.sh_entsize = sizeof (Elf64_External_Sym);
8978           section.sh_name = string_table_length;
8979
8980           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8981           if (num_dynamic_syms < 1)
8982             {
8983               error (_("Unable to determine the number of symbols to load\n"));
8984               continue;
8985             }
8986         }
8987     }
8988
8989   /* Similarly find a string table.  */
8990   if (dynamic_strings == NULL)
8991     {
8992       for (entry = dynamic_section;
8993            entry < dynamic_section + dynamic_nent;
8994            ++entry)
8995         {
8996           unsigned long offset;
8997           long str_tab_len;
8998
8999           if (entry->d_tag != DT_STRTAB)
9000             continue;
9001
9002           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9003
9004           /* Since we do not know how big the string table is,
9005              we default to reading in the entire file (!) and
9006              processing that.  This is overkill, I know, but it
9007              should work.  */
9008
9009           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9010
9011           if (archive_file_offset != 0)
9012             str_tab_len = archive_file_size - offset;
9013           else
9014             {
9015               if (fseek (file, 0, SEEK_END))
9016                 error (_("Unable to seek to end of file\n"));
9017               str_tab_len = ftell (file) - offset;
9018             }
9019
9020           if (str_tab_len < 1)
9021             {
9022               error
9023                 (_("Unable to determine the length of the dynamic string table\n"));
9024               continue;
9025             }
9026
9027           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9028                                                str_tab_len,
9029                                                _("dynamic string table"));
9030           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9031           break;
9032         }
9033     }
9034
9035   /* And find the syminfo section if available.  */
9036   if (dynamic_syminfo == NULL)
9037     {
9038       unsigned long syminsz = 0;
9039
9040       for (entry = dynamic_section;
9041            entry < dynamic_section + dynamic_nent;
9042            ++entry)
9043         {
9044           if (entry->d_tag == DT_SYMINENT)
9045             {
9046               /* Note: these braces are necessary to avoid a syntax
9047                  error from the SunOS4 C compiler.  */
9048               /* PR binutils/17531: A corrupt file can trigger this test.
9049                  So do not use an assert, instead generate an error message.  */
9050               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9051                 error (_("Bad value (%d) for SYMINENT entry\n"),
9052                        (int) entry->d_un.d_val);
9053             }
9054           else if (entry->d_tag == DT_SYMINSZ)
9055             syminsz = entry->d_un.d_val;
9056           else if (entry->d_tag == DT_SYMINFO)
9057             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9058                                                       syminsz);
9059         }
9060
9061       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9062         {
9063           Elf_External_Syminfo * extsyminfo;
9064           Elf_External_Syminfo * extsym;
9065           Elf_Internal_Syminfo * syminfo;
9066
9067           /* There is a syminfo section.  Read the data.  */
9068           extsyminfo = (Elf_External_Syminfo *)
9069               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9070                         _("symbol information"));
9071           if (!extsyminfo)
9072             return 0;
9073
9074           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9075           if (dynamic_syminfo == NULL)
9076             {
9077               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9078                      (unsigned long) syminsz);
9079               return 0;
9080             }
9081
9082           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9083           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9084                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9085                ++syminfo, ++extsym)
9086             {
9087               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9088               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9089             }
9090
9091           free (extsyminfo);
9092         }
9093     }
9094
9095   if (do_dynamic && dynamic_addr)
9096     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9097             dynamic_addr, (unsigned long) dynamic_nent);
9098   if (do_dynamic)
9099     printf (_("  Tag        Type                         Name/Value\n"));
9100
9101   for (entry = dynamic_section;
9102        entry < dynamic_section + dynamic_nent;
9103        entry++)
9104     {
9105       if (do_dynamic)
9106         {
9107           const char * dtype;
9108
9109           putchar (' ');
9110           print_vma (entry->d_tag, FULL_HEX);
9111           dtype = get_dynamic_type (entry->d_tag);
9112           printf (" (%s)%*s", dtype,
9113                   ((is_32bit_elf ? 27 : 19)
9114                    - (int) strlen (dtype)),
9115                   " ");
9116         }
9117
9118       switch (entry->d_tag)
9119         {
9120         case DT_FLAGS:
9121           if (do_dynamic)
9122             print_dynamic_flags (entry->d_un.d_val);
9123           break;
9124
9125         case DT_AUXILIARY:
9126         case DT_FILTER:
9127         case DT_CONFIG:
9128         case DT_DEPAUDIT:
9129         case DT_AUDIT:
9130           if (do_dynamic)
9131             {
9132               switch (entry->d_tag)
9133                 {
9134                 case DT_AUXILIARY:
9135                   printf (_("Auxiliary library"));
9136                   break;
9137
9138                 case DT_FILTER:
9139                   printf (_("Filter library"));
9140                   break;
9141
9142                 case DT_CONFIG:
9143                   printf (_("Configuration file"));
9144                   break;
9145
9146                 case DT_DEPAUDIT:
9147                   printf (_("Dependency audit library"));
9148                   break;
9149
9150                 case DT_AUDIT:
9151                   printf (_("Audit library"));
9152                   break;
9153                 }
9154
9155               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9156                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9157               else
9158                 {
9159                   printf (": ");
9160                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9161                   putchar ('\n');
9162                 }
9163             }
9164           break;
9165
9166         case DT_FEATURE:
9167           if (do_dynamic)
9168             {
9169               printf (_("Flags:"));
9170
9171               if (entry->d_un.d_val == 0)
9172                 printf (_(" None\n"));
9173               else
9174                 {
9175                   unsigned long int val = entry->d_un.d_val;
9176
9177                   if (val & DTF_1_PARINIT)
9178                     {
9179                       printf (" PARINIT");
9180                       val ^= DTF_1_PARINIT;
9181                     }
9182                   if (val & DTF_1_CONFEXP)
9183                     {
9184                       printf (" CONFEXP");
9185                       val ^= DTF_1_CONFEXP;
9186                     }
9187                   if (val != 0)
9188                     printf (" %lx", val);
9189                   puts ("");
9190                 }
9191             }
9192           break;
9193
9194         case DT_POSFLAG_1:
9195           if (do_dynamic)
9196             {
9197               printf (_("Flags:"));
9198
9199               if (entry->d_un.d_val == 0)
9200                 printf (_(" None\n"));
9201               else
9202                 {
9203                   unsigned long int val = entry->d_un.d_val;
9204
9205                   if (val & DF_P1_LAZYLOAD)
9206                     {
9207                       printf (" LAZYLOAD");
9208                       val ^= DF_P1_LAZYLOAD;
9209                     }
9210                   if (val & DF_P1_GROUPPERM)
9211                     {
9212                       printf (" GROUPPERM");
9213                       val ^= DF_P1_GROUPPERM;
9214                     }
9215                   if (val != 0)
9216                     printf (" %lx", val);
9217                   puts ("");
9218                 }
9219             }
9220           break;
9221
9222         case DT_FLAGS_1:
9223           if (do_dynamic)
9224             {
9225               printf (_("Flags:"));
9226               if (entry->d_un.d_val == 0)
9227                 printf (_(" None\n"));
9228               else
9229                 {
9230                   unsigned long int val = entry->d_un.d_val;
9231
9232                   if (val & DF_1_NOW)
9233                     {
9234                       printf (" NOW");
9235                       val ^= DF_1_NOW;
9236                     }
9237                   if (val & DF_1_GLOBAL)
9238                     {
9239                       printf (" GLOBAL");
9240                       val ^= DF_1_GLOBAL;
9241                     }
9242                   if (val & DF_1_GROUP)
9243                     {
9244                       printf (" GROUP");
9245                       val ^= DF_1_GROUP;
9246                     }
9247                   if (val & DF_1_NODELETE)
9248                     {
9249                       printf (" NODELETE");
9250                       val ^= DF_1_NODELETE;
9251                     }
9252                   if (val & DF_1_LOADFLTR)
9253                     {
9254                       printf (" LOADFLTR");
9255                       val ^= DF_1_LOADFLTR;
9256                     }
9257                   if (val & DF_1_INITFIRST)
9258                     {
9259                       printf (" INITFIRST");
9260                       val ^= DF_1_INITFIRST;
9261                     }
9262                   if (val & DF_1_NOOPEN)
9263                     {
9264                       printf (" NOOPEN");
9265                       val ^= DF_1_NOOPEN;
9266                     }
9267                   if (val & DF_1_ORIGIN)
9268                     {
9269                       printf (" ORIGIN");
9270                       val ^= DF_1_ORIGIN;
9271                     }
9272                   if (val & DF_1_DIRECT)
9273                     {
9274                       printf (" DIRECT");
9275                       val ^= DF_1_DIRECT;
9276                     }
9277                   if (val & DF_1_TRANS)
9278                     {
9279                       printf (" TRANS");
9280                       val ^= DF_1_TRANS;
9281                     }
9282                   if (val & DF_1_INTERPOSE)
9283                     {
9284                       printf (" INTERPOSE");
9285                       val ^= DF_1_INTERPOSE;
9286                     }
9287                   if (val & DF_1_NODEFLIB)
9288                     {
9289                       printf (" NODEFLIB");
9290                       val ^= DF_1_NODEFLIB;
9291                     }
9292                   if (val & DF_1_NODUMP)
9293                     {
9294                       printf (" NODUMP");
9295                       val ^= DF_1_NODUMP;
9296                     }
9297                   if (val & DF_1_CONFALT)
9298                     {
9299                       printf (" CONFALT");
9300                       val ^= DF_1_CONFALT;
9301                     }
9302                   if (val & DF_1_ENDFILTEE)
9303                     {
9304                       printf (" ENDFILTEE");
9305                       val ^= DF_1_ENDFILTEE;
9306                     }
9307                   if (val & DF_1_DISPRELDNE)
9308                     {
9309                       printf (" DISPRELDNE");
9310                       val ^= DF_1_DISPRELDNE;
9311                     }
9312                   if (val & DF_1_DISPRELPND)
9313                     {
9314                       printf (" DISPRELPND");
9315                       val ^= DF_1_DISPRELPND;
9316                     }
9317                   if (val & DF_1_NODIRECT)
9318                     {
9319                       printf (" NODIRECT");
9320                       val ^= DF_1_NODIRECT;
9321                     }
9322                   if (val & DF_1_IGNMULDEF)
9323                     {
9324                       printf (" IGNMULDEF");
9325                       val ^= DF_1_IGNMULDEF;
9326                     }
9327                   if (val & DF_1_NOKSYMS)
9328                     {
9329                       printf (" NOKSYMS");
9330                       val ^= DF_1_NOKSYMS;
9331                     }
9332                   if (val & DF_1_NOHDR)
9333                     {
9334                       printf (" NOHDR");
9335                       val ^= DF_1_NOHDR;
9336                     }
9337                   if (val & DF_1_EDITED)
9338                     {
9339                       printf (" EDITED");
9340                       val ^= DF_1_EDITED;
9341                     }
9342                   if (val & DF_1_NORELOC)
9343                     {
9344                       printf (" NORELOC");
9345                       val ^= DF_1_NORELOC;
9346                     }
9347                   if (val & DF_1_SYMINTPOSE)
9348                     {
9349                       printf (" SYMINTPOSE");
9350                       val ^= DF_1_SYMINTPOSE;
9351                     }
9352                   if (val & DF_1_GLOBAUDIT)
9353                     {
9354                       printf (" GLOBAUDIT");
9355                       val ^= DF_1_GLOBAUDIT;
9356                     }
9357                   if (val & DF_1_SINGLETON)
9358                     {
9359                       printf (" SINGLETON");
9360                       val ^= DF_1_SINGLETON;
9361                     }
9362                   if (val & DF_1_STUB)
9363                     {
9364                       printf (" STUB");
9365                       val ^= DF_1_STUB;
9366                     }
9367                   if (val & DF_1_PIE)
9368                     {
9369                       printf (" PIE");
9370                       val ^= DF_1_PIE;
9371                     }
9372                   if (val != 0)
9373                     printf (" %lx", val);
9374                   puts ("");
9375                 }
9376             }
9377           break;
9378
9379         case DT_PLTREL:
9380           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9381           if (do_dynamic)
9382             puts (get_dynamic_type (entry->d_un.d_val));
9383           break;
9384
9385         case DT_NULL    :
9386         case DT_NEEDED  :
9387         case DT_PLTGOT  :
9388         case DT_HASH    :
9389         case DT_STRTAB  :
9390         case DT_SYMTAB  :
9391         case DT_RELA    :
9392         case DT_INIT    :
9393         case DT_FINI    :
9394         case DT_SONAME  :
9395         case DT_RPATH   :
9396         case DT_SYMBOLIC:
9397         case DT_REL     :
9398         case DT_DEBUG   :
9399         case DT_TEXTREL :
9400         case DT_JMPREL  :
9401         case DT_RUNPATH :
9402           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9403
9404           if (do_dynamic)
9405             {
9406               char * name;
9407
9408               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9409                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9410               else
9411                 name = NULL;
9412
9413               if (name)
9414                 {
9415                   switch (entry->d_tag)
9416                     {
9417                     case DT_NEEDED:
9418                       printf (_("Shared library: [%s]"), name);
9419
9420                       if (streq (name, program_interpreter))
9421                         printf (_(" program interpreter"));
9422                       break;
9423
9424                     case DT_SONAME:
9425                       printf (_("Library soname: [%s]"), name);
9426                       break;
9427
9428                     case DT_RPATH:
9429                       printf (_("Library rpath: [%s]"), name);
9430                       break;
9431
9432                     case DT_RUNPATH:
9433                       printf (_("Library runpath: [%s]"), name);
9434                       break;
9435
9436                     default:
9437                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9438                       break;
9439                     }
9440                 }
9441               else
9442                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9443
9444               putchar ('\n');
9445             }
9446           break;
9447
9448         case DT_PLTRELSZ:
9449         case DT_RELASZ  :
9450         case DT_STRSZ   :
9451         case DT_RELSZ   :
9452         case DT_RELAENT :
9453         case DT_SYMENT  :
9454         case DT_RELENT  :
9455           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9456         case DT_PLTPADSZ:
9457         case DT_MOVEENT :
9458         case DT_MOVESZ  :
9459         case DT_INIT_ARRAYSZ:
9460         case DT_FINI_ARRAYSZ:
9461         case DT_GNU_CONFLICTSZ:
9462         case DT_GNU_LIBLISTSZ:
9463           if (do_dynamic)
9464             {
9465               print_vma (entry->d_un.d_val, UNSIGNED);
9466               printf (_(" (bytes)\n"));
9467             }
9468           break;
9469
9470         case DT_VERDEFNUM:
9471         case DT_VERNEEDNUM:
9472         case DT_RELACOUNT:
9473         case DT_RELCOUNT:
9474           if (do_dynamic)
9475             {
9476               print_vma (entry->d_un.d_val, UNSIGNED);
9477               putchar ('\n');
9478             }
9479           break;
9480
9481         case DT_SYMINSZ:
9482         case DT_SYMINENT:
9483         case DT_SYMINFO:
9484         case DT_USED:
9485         case DT_INIT_ARRAY:
9486         case DT_FINI_ARRAY:
9487           if (do_dynamic)
9488             {
9489               if (entry->d_tag == DT_USED
9490                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9491                 {
9492                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9493
9494                   if (*name)
9495                     {
9496                       printf (_("Not needed object: [%s]\n"), name);
9497                       break;
9498                     }
9499                 }
9500
9501               print_vma (entry->d_un.d_val, PREFIX_HEX);
9502               putchar ('\n');
9503             }
9504           break;
9505
9506         case DT_BIND_NOW:
9507           /* The value of this entry is ignored.  */
9508           if (do_dynamic)
9509             putchar ('\n');
9510           break;
9511
9512         case DT_GNU_PRELINKED:
9513           if (do_dynamic)
9514             {
9515               struct tm * tmp;
9516               time_t atime = entry->d_un.d_val;
9517
9518               tmp = gmtime (&atime);
9519               /* PR 17533 file: 041-1244816-0.004.  */
9520               if (tmp == NULL)
9521                 printf (_("<corrupt time val: %lx"),
9522                         (unsigned long) atime);
9523               else
9524                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9525                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9526                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9527
9528             }
9529           break;
9530
9531         case DT_GNU_HASH:
9532           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9533           if (do_dynamic)
9534             {
9535               print_vma (entry->d_un.d_val, PREFIX_HEX);
9536               putchar ('\n');
9537             }
9538           break;
9539
9540         default:
9541           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9542             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9543               entry->d_un.d_val;
9544
9545           if (do_dynamic)
9546             {
9547               switch (elf_header.e_machine)
9548                 {
9549                 case EM_MIPS:
9550                 case EM_MIPS_RS3_LE:
9551                   dynamic_section_mips_val (entry);
9552                   break;
9553                 case EM_PARISC:
9554                   dynamic_section_parisc_val (entry);
9555                   break;
9556                 case EM_IA_64:
9557                   dynamic_section_ia64_val (entry);
9558                   break;
9559                 default:
9560                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9561                   putchar ('\n');
9562                 }
9563             }
9564           break;
9565         }
9566     }
9567
9568   return 1;
9569 }
9570
9571 static char *
9572 get_ver_flags (unsigned int flags)
9573 {
9574   static char buff[32];
9575
9576   buff[0] = 0;
9577
9578   if (flags == 0)
9579     return _("none");
9580
9581   if (flags & VER_FLG_BASE)
9582     strcat (buff, "BASE ");
9583
9584   if (flags & VER_FLG_WEAK)
9585     {
9586       if (flags & VER_FLG_BASE)
9587         strcat (buff, "| ");
9588
9589       strcat (buff, "WEAK ");
9590     }
9591
9592   if (flags & VER_FLG_INFO)
9593     {
9594       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9595         strcat (buff, "| ");
9596
9597       strcat (buff, "INFO ");
9598     }
9599
9600   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9601     strcat (buff, _("| <unknown>"));
9602
9603   return buff;
9604 }
9605
9606 /* Display the contents of the version sections.  */
9607
9608 static int
9609 process_version_sections (FILE * file)
9610 {
9611   Elf_Internal_Shdr * section;
9612   unsigned i;
9613   int found = 0;
9614
9615   if (! do_version)
9616     return 1;
9617
9618   for (i = 0, section = section_headers;
9619        i < elf_header.e_shnum;
9620        i++, section++)
9621     {
9622       switch (section->sh_type)
9623         {
9624         case SHT_GNU_verdef:
9625           {
9626             Elf_External_Verdef * edefs;
9627             unsigned int idx;
9628             unsigned int cnt;
9629             char * endbuf;
9630
9631             found = 1;
9632
9633             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9634                     printable_section_name (section),
9635                     section->sh_info);
9636
9637             printf (_("  Addr: 0x"));
9638             printf_vma (section->sh_addr);
9639             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9640                     (unsigned long) section->sh_offset, section->sh_link,
9641                     printable_section_name_from_index (section->sh_link));
9642
9643             edefs = (Elf_External_Verdef *)
9644                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9645                           _("version definition section"));
9646             if (!edefs)
9647               break;
9648             endbuf = (char *) edefs + section->sh_size;
9649
9650             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9651               {
9652                 char * vstart;
9653                 Elf_External_Verdef * edef;
9654                 Elf_Internal_Verdef ent;
9655                 Elf_External_Verdaux * eaux;
9656                 Elf_Internal_Verdaux aux;
9657                 int j;
9658                 int isum;
9659
9660                 /* Check for very large indicies.  */
9661                 if (idx > (size_t) (endbuf - (char *) edefs))
9662                   break;
9663
9664                 vstart = ((char *) edefs) + idx;
9665                 if (vstart + sizeof (*edef) > endbuf)
9666                   break;
9667
9668                 edef = (Elf_External_Verdef *) vstart;
9669
9670                 ent.vd_version = BYTE_GET (edef->vd_version);
9671                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9672                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9673                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9674                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9675                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9676                 ent.vd_next    = BYTE_GET (edef->vd_next);
9677
9678                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9679                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9680
9681                 printf (_("  Index: %d  Cnt: %d  "),
9682                         ent.vd_ndx, ent.vd_cnt);
9683
9684                 /* Check for overflow.  */
9685                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9686                   break;
9687
9688                 vstart += ent.vd_aux;
9689
9690                 eaux = (Elf_External_Verdaux *) vstart;
9691
9692                 aux.vda_name = BYTE_GET (eaux->vda_name);
9693                 aux.vda_next = BYTE_GET (eaux->vda_next);
9694
9695                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9696                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9697                 else
9698                   printf (_("Name index: %ld\n"), aux.vda_name);
9699
9700                 isum = idx + ent.vd_aux;
9701
9702                 for (j = 1; j < ent.vd_cnt; j++)
9703                   {
9704                     /* Check for overflow.  */
9705                     if (aux.vda_next > (size_t) (endbuf - vstart))
9706                       break;
9707
9708                     isum   += aux.vda_next;
9709                     vstart += aux.vda_next;
9710
9711                     eaux = (Elf_External_Verdaux *) vstart;
9712                     if (vstart + sizeof (*eaux) > endbuf)
9713                       break;
9714
9715                     aux.vda_name = BYTE_GET (eaux->vda_name);
9716                     aux.vda_next = BYTE_GET (eaux->vda_next);
9717
9718                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9719                       printf (_("  %#06x: Parent %d: %s\n"),
9720                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9721                     else
9722                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9723                               isum, j, aux.vda_name);
9724                   }
9725
9726                 if (j < ent.vd_cnt)
9727                   printf (_("  Version def aux past end of section\n"));
9728
9729                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9730                 if (idx + ent.vd_next <= idx)
9731                   break;
9732
9733                 idx += ent.vd_next;
9734               }
9735
9736             if (cnt < section->sh_info)
9737               printf (_("  Version definition past end of section\n"));
9738
9739             free (edefs);
9740           }
9741           break;
9742
9743         case SHT_GNU_verneed:
9744           {
9745             Elf_External_Verneed * eneed;
9746             unsigned int idx;
9747             unsigned int cnt;
9748             char * endbuf;
9749
9750             found = 1;
9751
9752             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9753                     printable_section_name (section), section->sh_info);
9754
9755             printf (_(" Addr: 0x"));
9756             printf_vma (section->sh_addr);
9757             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9758                     (unsigned long) section->sh_offset, section->sh_link,
9759                     printable_section_name_from_index (section->sh_link));
9760
9761             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9762                                                        section->sh_offset, 1,
9763                                                        section->sh_size,
9764                                                        _("Version Needs section"));
9765             if (!eneed)
9766               break;
9767             endbuf = (char *) eneed + section->sh_size;
9768
9769             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9770               {
9771                 Elf_External_Verneed * entry;
9772                 Elf_Internal_Verneed ent;
9773                 int j;
9774                 int isum;
9775                 char * vstart;
9776
9777                 if (idx > (size_t) (endbuf - (char *) eneed))
9778                   break;
9779
9780                 vstart = ((char *) eneed) + idx;
9781                 if (vstart + sizeof (*entry) > endbuf)
9782                   break;
9783
9784                 entry = (Elf_External_Verneed *) vstart;
9785
9786                 ent.vn_version = BYTE_GET (entry->vn_version);
9787                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9788                 ent.vn_file    = BYTE_GET (entry->vn_file);
9789                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9790                 ent.vn_next    = BYTE_GET (entry->vn_next);
9791
9792                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9793
9794                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9795                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9796                 else
9797                   printf (_("  File: %lx"), ent.vn_file);
9798
9799                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9800
9801                 /* Check for overflow.  */
9802                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9803                   break;
9804                 vstart += ent.vn_aux;
9805
9806                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9807                   {
9808                     Elf_External_Vernaux * eaux;
9809                     Elf_Internal_Vernaux aux;
9810
9811                     if (vstart + sizeof (*eaux) > endbuf)
9812                       break;
9813                     eaux = (Elf_External_Vernaux *) vstart;
9814
9815                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9816                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9817                     aux.vna_other = BYTE_GET (eaux->vna_other);
9818                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9819                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9820
9821                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9822                       printf (_("  %#06x:   Name: %s"),
9823                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9824                     else
9825                       printf (_("  %#06x:   Name index: %lx"),
9826                               isum, aux.vna_name);
9827
9828                     printf (_("  Flags: %s  Version: %d\n"),
9829                             get_ver_flags (aux.vna_flags), aux.vna_other);
9830
9831                     /* Check for overflow.  */
9832                     if (aux.vna_next > (size_t) (endbuf - vstart)
9833                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9834                       {
9835                         warn (_("Invalid vna_next field of %lx\n"),
9836                               aux.vna_next);
9837                         j = ent.vn_cnt;
9838                         break;
9839                       }
9840                     isum   += aux.vna_next;
9841                     vstart += aux.vna_next;
9842                   }
9843
9844                 if (j < ent.vn_cnt)
9845                   warn (_("Missing Version Needs auxillary information\n"));
9846
9847                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9848                   {
9849                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9850                     cnt = section->sh_info;
9851                     break;
9852                   }
9853                 idx += ent.vn_next;
9854               }
9855
9856             if (cnt < section->sh_info)
9857               warn (_("Missing Version Needs information\n"));
9858
9859             free (eneed);
9860           }
9861           break;
9862
9863         case SHT_GNU_versym:
9864           {
9865             Elf_Internal_Shdr * link_section;
9866             size_t total;
9867             unsigned int cnt;
9868             unsigned char * edata;
9869             unsigned short * data;
9870             char * strtab;
9871             Elf_Internal_Sym * symbols;
9872             Elf_Internal_Shdr * string_sec;
9873             unsigned long num_syms;
9874             long off;
9875
9876             if (section->sh_link >= elf_header.e_shnum)
9877               break;
9878
9879             link_section = section_headers + section->sh_link;
9880             total = section->sh_size / sizeof (Elf_External_Versym);
9881
9882             if (link_section->sh_link >= elf_header.e_shnum)
9883               break;
9884
9885             found = 1;
9886
9887             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9888             if (symbols == NULL)
9889               break;
9890
9891             string_sec = section_headers + link_section->sh_link;
9892
9893             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9894                                         string_sec->sh_size,
9895                                         _("version string table"));
9896             if (!strtab)
9897               {
9898                 free (symbols);
9899                 break;
9900               }
9901
9902             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9903                     printable_section_name (section), (unsigned long) total);
9904
9905             printf (_(" Addr: "));
9906             printf_vma (section->sh_addr);
9907             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9908                     (unsigned long) section->sh_offset, section->sh_link,
9909                     printable_section_name (link_section));
9910
9911             off = offset_from_vma (file,
9912                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9913                                    total * sizeof (short));
9914             edata = (unsigned char *) get_data (NULL, file, off, total,
9915                                                 sizeof (short),
9916                                                 _("version symbol data"));
9917             if (!edata)
9918               {
9919                 free (strtab);
9920                 free (symbols);
9921                 break;
9922               }
9923
9924             data = (short unsigned int *) cmalloc (total, sizeof (short));
9925
9926             for (cnt = total; cnt --;)
9927               data[cnt] = byte_get (edata + cnt * sizeof (short),
9928                                     sizeof (short));
9929
9930             free (edata);
9931
9932             for (cnt = 0; cnt < total; cnt += 4)
9933               {
9934                 int j, nn;
9935                 char *name;
9936                 char *invalid = _("*invalid*");
9937
9938                 printf ("  %03x:", cnt);
9939
9940                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9941                   switch (data[cnt + j])
9942                     {
9943                     case 0:
9944                       fputs (_("   0 (*local*)    "), stdout);
9945                       break;
9946
9947                     case 1:
9948                       fputs (_("   1 (*global*)   "), stdout);
9949                       break;
9950
9951                     default:
9952                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9953                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9954
9955                       /* If this index value is greater than the size of the symbols
9956                          array, break to avoid an out-of-bounds read.  */
9957                       if ((unsigned long)(cnt + j) >= num_syms)
9958                         {
9959                           warn (_("invalid index into symbol array\n"));
9960                           break;
9961                         }
9962
9963                       name = NULL;
9964                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9965                         {
9966                           Elf_Internal_Verneed ivn;
9967                           unsigned long offset;
9968
9969                           offset = offset_from_vma
9970                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9971                              sizeof (Elf_External_Verneed));
9972
9973                           do
9974                             {
9975                               Elf_Internal_Vernaux ivna;
9976                               Elf_External_Verneed evn;
9977                               Elf_External_Vernaux evna;
9978                               unsigned long a_off;
9979
9980                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9981                                             _("version need")) == NULL)
9982                                 break;
9983
9984                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9985                               ivn.vn_next = BYTE_GET (evn.vn_next);
9986
9987                               a_off = offset + ivn.vn_aux;
9988
9989                               do
9990                                 {
9991                                   if (get_data (&evna, file, a_off, sizeof (evna),
9992                                                 1, _("version need aux (2)")) == NULL)
9993                                     {
9994                                       ivna.vna_next  = 0;
9995                                       ivna.vna_other = 0;
9996                                     }
9997                                   else
9998                                     {
9999                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10000                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10001                                     }
10002
10003                                   a_off += ivna.vna_next;
10004                                 }
10005                               while (ivna.vna_other != data[cnt + j]
10006                                      && ivna.vna_next != 0);
10007
10008                               if (ivna.vna_other == data[cnt + j])
10009                                 {
10010                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10011
10012                                   if (ivna.vna_name >= string_sec->sh_size)
10013                                     name = invalid;
10014                                   else
10015                                     name = strtab + ivna.vna_name;
10016                                   break;
10017                                 }
10018
10019                               offset += ivn.vn_next;
10020                             }
10021                           while (ivn.vn_next);
10022                         }
10023
10024                       if (data[cnt + j] != 0x8001
10025                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10026                         {
10027                           Elf_Internal_Verdef ivd;
10028                           Elf_External_Verdef evd;
10029                           unsigned long offset;
10030
10031                           offset = offset_from_vma
10032                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10033                              sizeof evd);
10034
10035                           do
10036                             {
10037                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10038                                             _("version def")) == NULL)
10039                                 {
10040                                   ivd.vd_next = 0;
10041                                   /* PR 17531: file: 046-1082287-0.004.  */
10042                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10043                                   break;
10044                                 }
10045                               else
10046                                 {
10047                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10048                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10049                                 }
10050
10051                               offset += ivd.vd_next;
10052                             }
10053                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10054                                  && ivd.vd_next != 0);
10055
10056                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10057                             {
10058                               Elf_External_Verdaux evda;
10059                               Elf_Internal_Verdaux ivda;
10060
10061                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10062
10063                               if (get_data (&evda, file,
10064                                             offset - ivd.vd_next + ivd.vd_aux,
10065                                             sizeof (evda), 1,
10066                                             _("version def aux")) == NULL)
10067                                 break;
10068
10069                               ivda.vda_name = BYTE_GET (evda.vda_name);
10070
10071                               if (ivda.vda_name >= string_sec->sh_size)
10072                                 name = invalid;
10073                               else if (name != NULL && name != invalid)
10074                                 name = _("*both*");
10075                               else
10076                                 name = strtab + ivda.vda_name;
10077                             }
10078                         }
10079                       if (name != NULL)
10080                         nn += printf ("(%s%-*s",
10081                                       name,
10082                                       12 - (int) strlen (name),
10083                                       ")");
10084
10085                       if (nn < 18)
10086                         printf ("%*c", 18 - nn, ' ');
10087                     }
10088
10089                 putchar ('\n');
10090               }
10091
10092             free (data);
10093             free (strtab);
10094             free (symbols);
10095           }
10096           break;
10097
10098         default:
10099           break;
10100         }
10101     }
10102
10103   if (! found)
10104     printf (_("\nNo version information found in this file.\n"));
10105
10106   return 1;
10107 }
10108
10109 static const char *
10110 get_symbol_binding (unsigned int binding)
10111 {
10112   static char buff[32];
10113
10114   switch (binding)
10115     {
10116     case STB_LOCAL:     return "LOCAL";
10117     case STB_GLOBAL:    return "GLOBAL";
10118     case STB_WEAK:      return "WEAK";
10119     default:
10120       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10121         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10122                   binding);
10123       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10124         {
10125           if (binding == STB_GNU_UNIQUE
10126               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10127                   /* GNU is still using the default value 0.  */
10128                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10129             return "UNIQUE";
10130           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10131         }
10132       else
10133         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10134       return buff;
10135     }
10136 }
10137
10138 static const char *
10139 get_symbol_type (unsigned int type)
10140 {
10141   static char buff[32];
10142
10143   switch (type)
10144     {
10145     case STT_NOTYPE:    return "NOTYPE";
10146     case STT_OBJECT:    return "OBJECT";
10147     case STT_FUNC:      return "FUNC";
10148     case STT_SECTION:   return "SECTION";
10149     case STT_FILE:      return "FILE";
10150     case STT_COMMON:    return "COMMON";
10151     case STT_TLS:       return "TLS";
10152     case STT_RELC:      return "RELC";
10153     case STT_SRELC:     return "SRELC";
10154     default:
10155       if (type >= STT_LOPROC && type <= STT_HIPROC)
10156         {
10157           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10158             return "THUMB_FUNC";
10159
10160           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10161             return "REGISTER";
10162
10163           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10164             return "PARISC_MILLI";
10165
10166           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10167         }
10168       else if (type >= STT_LOOS && type <= STT_HIOS)
10169         {
10170           if (elf_header.e_machine == EM_PARISC)
10171             {
10172               if (type == STT_HP_OPAQUE)
10173                 return "HP_OPAQUE";
10174               if (type == STT_HP_STUB)
10175                 return "HP_STUB";
10176             }
10177
10178           if (type == STT_GNU_IFUNC
10179               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10180                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10181                   /* GNU is still using the default value 0.  */
10182                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10183             return "IFUNC";
10184
10185           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10186         }
10187       else
10188         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10189       return buff;
10190     }
10191 }
10192
10193 static const char *
10194 get_symbol_visibility (unsigned int visibility)
10195 {
10196   switch (visibility)
10197     {
10198     case STV_DEFAULT:   return "DEFAULT";
10199     case STV_INTERNAL:  return "INTERNAL";
10200     case STV_HIDDEN:    return "HIDDEN";
10201     case STV_PROTECTED: return "PROTECTED";
10202     default:
10203       error (_("Unrecognized visibility value: %u"), visibility);
10204       return _("<unknown>");
10205     }
10206 }
10207
10208 static const char *
10209 get_mips_symbol_other (unsigned int other)
10210 {
10211   switch (other)
10212     {
10213     case STO_OPTIONAL:
10214       return "OPTIONAL";
10215     case STO_MIPS_PLT:
10216       return "MIPS PLT";
10217     case STO_MIPS_PIC:
10218       return "MIPS PIC";
10219     case STO_MICROMIPS:
10220       return "MICROMIPS";
10221     case STO_MICROMIPS | STO_MIPS_PIC:
10222       return "MICROMIPS, MIPS PIC";
10223     case STO_MIPS16:
10224       return "MIPS16";
10225     default:
10226       return NULL;
10227     }
10228 }
10229
10230 static const char *
10231 get_ia64_symbol_other (unsigned int other)
10232 {
10233   if (is_ia64_vms ())
10234     {
10235       static char res[32];
10236
10237       res[0] = 0;
10238
10239       /* Function types is for images and .STB files only.  */
10240       switch (elf_header.e_type)
10241         {
10242         case ET_DYN:
10243         case ET_EXEC:
10244           switch (VMS_ST_FUNC_TYPE (other))
10245             {
10246             case VMS_SFT_CODE_ADDR:
10247               strcat (res, " CA");
10248               break;
10249             case VMS_SFT_SYMV_IDX:
10250               strcat (res, " VEC");
10251               break;
10252             case VMS_SFT_FD:
10253               strcat (res, " FD");
10254               break;
10255             case VMS_SFT_RESERVE:
10256               strcat (res, " RSV");
10257               break;
10258             default:
10259               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10260                     VMS_ST_FUNC_TYPE (other));
10261               strcat (res, " <unknown>");
10262               break;
10263             }
10264           break;
10265         default:
10266           break;
10267         }
10268       switch (VMS_ST_LINKAGE (other))
10269         {
10270         case VMS_STL_IGNORE:
10271           strcat (res, " IGN");
10272           break;
10273         case VMS_STL_RESERVE:
10274           strcat (res, " RSV");
10275           break;
10276         case VMS_STL_STD:
10277           strcat (res, " STD");
10278           break;
10279         case VMS_STL_LNK:
10280           strcat (res, " LNK");
10281           break;
10282         default:
10283           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10284                 VMS_ST_LINKAGE (other));
10285           strcat (res, " <unknown>");
10286           break;
10287         }
10288
10289       if (res[0] != 0)
10290         return res + 1;
10291       else
10292         return res;
10293     }
10294   return NULL;
10295 }
10296
10297 static const char *
10298 get_ppc64_symbol_other (unsigned int other)
10299 {
10300   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10301     {
10302       static char buf[32];
10303       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10304                 PPC64_LOCAL_ENTRY_OFFSET (other));
10305       return buf;
10306     }
10307   return NULL;
10308 }
10309
10310 static const char *
10311 get_symbol_other (unsigned int other)
10312 {
10313   const char * result = NULL;
10314   static char buff [32];
10315
10316   if (other == 0)
10317     return "";
10318
10319   switch (elf_header.e_machine)
10320     {
10321     case EM_MIPS:
10322       result = get_mips_symbol_other (other);
10323       break;
10324     case EM_IA_64:
10325       result = get_ia64_symbol_other (other);
10326       break;
10327     case EM_PPC64:
10328       result = get_ppc64_symbol_other (other);
10329       break;
10330     default:
10331       break;
10332     }
10333
10334   if (result)
10335     return result;
10336
10337   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10338   return buff;
10339 }
10340
10341 static const char *
10342 get_symbol_index_type (unsigned int type)
10343 {
10344   static char buff[32];
10345
10346   switch (type)
10347     {
10348     case SHN_UNDEF:     return "UND";
10349     case SHN_ABS:       return "ABS";
10350     case SHN_COMMON:    return "COM";
10351     default:
10352       if (type == SHN_IA_64_ANSI_COMMON
10353           && elf_header.e_machine == EM_IA_64
10354           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10355         return "ANSI_COM";
10356       else if ((elf_header.e_machine == EM_X86_64
10357                 || elf_header.e_machine == EM_L1OM
10358                 || elf_header.e_machine == EM_K1OM)
10359                && type == SHN_X86_64_LCOMMON)
10360         return "LARGE_COM";
10361       else if ((type == SHN_MIPS_SCOMMON
10362                 && elf_header.e_machine == EM_MIPS)
10363                || (type == SHN_TIC6X_SCOMMON
10364                    && elf_header.e_machine == EM_TI_C6000))
10365         return "SCOM";
10366       else if (type == SHN_MIPS_SUNDEFINED
10367                && elf_header.e_machine == EM_MIPS)
10368         return "SUND";
10369       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10370         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10371       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10372         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10373       else if (type >= SHN_LORESERVE)
10374         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10375       else if (type >= elf_header.e_shnum)
10376         sprintf (buff, _("bad section index[%3d]"), type);
10377       else
10378         sprintf (buff, "%3d", type);
10379       break;
10380     }
10381
10382   return buff;
10383 }
10384
10385 static bfd_vma *
10386 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10387 {
10388   unsigned char * e_data;
10389   bfd_vma * i_data;
10390
10391   /* If the size_t type is smaller than the bfd_size_type, eg because
10392      you are building a 32-bit tool on a 64-bit host, then make sure
10393      that when (number) is cast to (size_t) no information is lost.  */
10394   if (sizeof (size_t) < sizeof (bfd_size_type)
10395       && (bfd_size_type) ((size_t) number) != number)
10396     {
10397       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10398              (unsigned long long) number, ent_size);
10399       return NULL;
10400     }
10401
10402   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10403      attempting to allocate memory when the read is bound to fail.  */
10404   if (ent_size * number > current_file_size)
10405     {
10406       error (_("Invalid number of dynamic entries: %llu\n"),
10407              (unsigned long long) number);
10408       return NULL;
10409     }
10410
10411   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10412   if (e_data == NULL)
10413     {
10414       error (_("Out of memory reading %llu dynamic entries\n"),
10415              (unsigned long long) number);
10416       return NULL;
10417     }
10418
10419   if (fread (e_data, ent_size, (size_t) number, file) != number)
10420     {
10421       error (_("Unable to read in %llu bytes of dynamic data\n"),
10422              (unsigned long long) (number * ent_size));
10423       free (e_data);
10424       return NULL;
10425     }
10426
10427   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10428   if (i_data == NULL)
10429     {
10430       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10431              (unsigned long long) number);
10432       free (e_data);
10433       return NULL;
10434     }
10435
10436   while (number--)
10437     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10438
10439   free (e_data);
10440
10441   return i_data;
10442 }
10443
10444 static void
10445 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10446 {
10447   Elf_Internal_Sym * psym;
10448   int n;
10449
10450   n = print_vma (si, DEC_5);
10451   if (n < 5)
10452     fputs (&"     "[n], stdout);
10453   printf (" %3lu: ", hn);
10454
10455   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10456     {
10457       printf (_("<No info available for dynamic symbol number %lu>\n"),
10458               (unsigned long) si);
10459       return;
10460     }
10461
10462   psym = dynamic_symbols + si;
10463   print_vma (psym->st_value, LONG_HEX);
10464   putchar (' ');
10465   print_vma (psym->st_size, DEC_5);
10466
10467   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10468   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10469   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10470   /* Check to see if any other bits in the st_other field are set.
10471      Note - displaying this information disrupts the layout of the
10472      table being generated, but for the moment this case is very
10473      rare.  */
10474   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10475     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10476   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10477   if (VALID_DYNAMIC_NAME (psym->st_name))
10478     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10479   else
10480     printf (_(" <corrupt: %14ld>"), psym->st_name);
10481   putchar ('\n');
10482 }
10483
10484 static const char *
10485 get_symbol_version_string (FILE *file, int is_dynsym,
10486                            const char *strtab,
10487                            unsigned long int strtab_size,
10488                            unsigned int si, Elf_Internal_Sym *psym,
10489                            enum versioned_symbol_info *sym_info,
10490                            unsigned short *vna_other)
10491 {
10492   unsigned char data[2];
10493   unsigned short vers_data;
10494   unsigned long offset;
10495
10496   if (!is_dynsym
10497       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10498     return NULL;
10499
10500   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10501                             sizeof data + si * sizeof (vers_data));
10502
10503   if (get_data (&data, file, offset + si * sizeof (vers_data),
10504                 sizeof (data), 1, _("version data")) == NULL)
10505     return NULL;
10506
10507   vers_data = byte_get (data, 2);
10508
10509   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10510     return NULL;
10511
10512   /* Usually we'd only see verdef for defined symbols, and verneed for
10513      undefined symbols.  However, symbols defined by the linker in
10514      .dynbss for variables copied from a shared library in order to
10515      avoid text relocations are defined yet have verneed.  We could
10516      use a heuristic to detect the special case, for example, check
10517      for verneed first on symbols defined in SHT_NOBITS sections, but
10518      it is simpler and more reliable to just look for both verdef and
10519      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
10520
10521   if (psym->st_shndx != SHN_UNDEF
10522       && vers_data != 0x8001
10523       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10524     {
10525       Elf_Internal_Verdef ivd;
10526       Elf_Internal_Verdaux ivda;
10527       Elf_External_Verdaux evda;
10528       unsigned long off;
10529
10530       off = offset_from_vma (file,
10531                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10532                              sizeof (Elf_External_Verdef));
10533
10534       do
10535         {
10536           Elf_External_Verdef evd;
10537
10538           if (get_data (&evd, file, off, sizeof (evd), 1,
10539                         _("version def")) == NULL)
10540             {
10541               ivd.vd_ndx = 0;
10542               ivd.vd_aux = 0;
10543               ivd.vd_next = 0;
10544             }
10545           else
10546             {
10547               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10548               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10549               ivd.vd_next = BYTE_GET (evd.vd_next);
10550             }
10551
10552           off += ivd.vd_next;
10553         }
10554       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10555
10556       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10557         {
10558           off -= ivd.vd_next;
10559           off += ivd.vd_aux;
10560
10561           if (get_data (&evda, file, off, sizeof (evda), 1,
10562                         _("version def aux")) != NULL)
10563             {
10564               ivda.vda_name = BYTE_GET (evda.vda_name);
10565
10566               if (psym->st_name != ivda.vda_name)
10567                 {
10568                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10569                                ? symbol_hidden : symbol_public);
10570                   return (ivda.vda_name < strtab_size
10571                           ? strtab + ivda.vda_name : _("<corrupt>"));
10572                 }
10573             }
10574         }
10575     }
10576
10577   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10578     {
10579       Elf_External_Verneed evn;
10580       Elf_Internal_Verneed ivn;
10581       Elf_Internal_Vernaux ivna;
10582
10583       offset = offset_from_vma (file,
10584                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10585                                 sizeof evn);
10586       do
10587         {
10588           unsigned long vna_off;
10589
10590           if (get_data (&evn, file, offset, sizeof (evn), 1,
10591                         _("version need")) == NULL)
10592             {
10593               ivna.vna_next = 0;
10594               ivna.vna_other = 0;
10595               ivna.vna_name = 0;
10596               break;
10597             }
10598
10599           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10600           ivn.vn_next = BYTE_GET (evn.vn_next);
10601
10602           vna_off = offset + ivn.vn_aux;
10603
10604           do
10605             {
10606               Elf_External_Vernaux evna;
10607
10608               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10609                             _("version need aux (3)")) == NULL)
10610                 {
10611                   ivna.vna_next = 0;
10612                   ivna.vna_other = 0;
10613                   ivna.vna_name = 0;
10614                 }
10615               else
10616                 {
10617                   ivna.vna_other = BYTE_GET (evna.vna_other);
10618                   ivna.vna_next  = BYTE_GET (evna.vna_next);
10619                   ivna.vna_name  = BYTE_GET (evna.vna_name);
10620                 }
10621
10622               vna_off += ivna.vna_next;
10623             }
10624           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
10625
10626           if (ivna.vna_other == vers_data)
10627             break;
10628
10629           offset += ivn.vn_next;
10630         }
10631       while (ivn.vn_next != 0);
10632
10633       if (ivna.vna_other == vers_data)
10634         {
10635           *sym_info = symbol_undefined;
10636           *vna_other = ivna.vna_other;
10637           return (ivna.vna_name < strtab_size
10638                   ? strtab + ivna.vna_name : _("<corrupt>"));
10639         }
10640     }
10641   return NULL;
10642 }
10643
10644 /* Dump the symbol table.  */
10645 static int
10646 process_symbol_table (FILE * file)
10647 {
10648   Elf_Internal_Shdr * section;
10649   bfd_size_type nbuckets = 0;
10650   bfd_size_type nchains = 0;
10651   bfd_vma * buckets = NULL;
10652   bfd_vma * chains = NULL;
10653   bfd_vma ngnubuckets = 0;
10654   bfd_vma * gnubuckets = NULL;
10655   bfd_vma * gnuchains = NULL;
10656   bfd_vma gnusymidx = 0;
10657   bfd_size_type ngnuchains = 0;
10658
10659   if (!do_syms && !do_dyn_syms && !do_histogram)
10660     return 1;
10661
10662   if (dynamic_info[DT_HASH]
10663       && (do_histogram
10664           || (do_using_dynamic
10665               && !do_dyn_syms
10666               && dynamic_strings != NULL)))
10667     {
10668       unsigned char nb[8];
10669       unsigned char nc[8];
10670       unsigned int hash_ent_size = 4;
10671
10672       if ((elf_header.e_machine == EM_ALPHA
10673            || elf_header.e_machine == EM_S390
10674            || elf_header.e_machine == EM_S390_OLD)
10675           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10676         hash_ent_size = 8;
10677
10678       if (fseek (file,
10679                  (archive_file_offset
10680                   + offset_from_vma (file, dynamic_info[DT_HASH],
10681                                      sizeof nb + sizeof nc)),
10682                  SEEK_SET))
10683         {
10684           error (_("Unable to seek to start of dynamic information\n"));
10685           goto no_hash;
10686         }
10687
10688       if (fread (nb, hash_ent_size, 1, file) != 1)
10689         {
10690           error (_("Failed to read in number of buckets\n"));
10691           goto no_hash;
10692         }
10693
10694       if (fread (nc, hash_ent_size, 1, file) != 1)
10695         {
10696           error (_("Failed to read in number of chains\n"));
10697           goto no_hash;
10698         }
10699
10700       nbuckets = byte_get (nb, hash_ent_size);
10701       nchains  = byte_get (nc, hash_ent_size);
10702
10703       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10704       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10705
10706     no_hash:
10707       if (buckets == NULL || chains == NULL)
10708         {
10709           if (do_using_dynamic)
10710             return 0;
10711           free (buckets);
10712           free (chains);
10713           buckets = NULL;
10714           chains = NULL;
10715           nbuckets = 0;
10716           nchains = 0;
10717         }
10718     }
10719
10720   if (dynamic_info_DT_GNU_HASH
10721       && (do_histogram
10722           || (do_using_dynamic
10723               && !do_dyn_syms
10724               && dynamic_strings != NULL)))
10725     {
10726       unsigned char nb[16];
10727       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10728       bfd_vma buckets_vma;
10729
10730       if (fseek (file,
10731                  (archive_file_offset
10732                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10733                                      sizeof nb)),
10734                  SEEK_SET))
10735         {
10736           error (_("Unable to seek to start of dynamic information\n"));
10737           goto no_gnu_hash;
10738         }
10739
10740       if (fread (nb, 16, 1, file) != 1)
10741         {
10742           error (_("Failed to read in number of buckets\n"));
10743           goto no_gnu_hash;
10744         }
10745
10746       ngnubuckets = byte_get (nb, 4);
10747       gnusymidx = byte_get (nb + 4, 4);
10748       bitmaskwords = byte_get (nb + 8, 4);
10749       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10750       if (is_32bit_elf)
10751         buckets_vma += bitmaskwords * 4;
10752       else
10753         buckets_vma += bitmaskwords * 8;
10754
10755       if (fseek (file,
10756                  (archive_file_offset
10757                   + offset_from_vma (file, buckets_vma, 4)),
10758                  SEEK_SET))
10759         {
10760           error (_("Unable to seek to start of dynamic information\n"));
10761           goto no_gnu_hash;
10762         }
10763
10764       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10765
10766       if (gnubuckets == NULL)
10767         goto no_gnu_hash;
10768
10769       for (i = 0; i < ngnubuckets; i++)
10770         if (gnubuckets[i] != 0)
10771           {
10772             if (gnubuckets[i] < gnusymidx)
10773               return 0;
10774
10775             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10776               maxchain = gnubuckets[i];
10777           }
10778
10779       if (maxchain == 0xffffffff)
10780         goto no_gnu_hash;
10781
10782       maxchain -= gnusymidx;
10783
10784       if (fseek (file,
10785                  (archive_file_offset
10786                   + offset_from_vma (file, buckets_vma
10787                                            + 4 * (ngnubuckets + maxchain), 4)),
10788                  SEEK_SET))
10789         {
10790           error (_("Unable to seek to start of dynamic information\n"));
10791           goto no_gnu_hash;
10792         }
10793
10794       do
10795         {
10796           if (fread (nb, 4, 1, file) != 1)
10797             {
10798               error (_("Failed to determine last chain length\n"));
10799               goto no_gnu_hash;
10800             }
10801
10802           if (maxchain + 1 == 0)
10803             goto no_gnu_hash;
10804
10805           ++maxchain;
10806         }
10807       while ((byte_get (nb, 4) & 1) == 0);
10808
10809       if (fseek (file,
10810                  (archive_file_offset
10811                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10812                  SEEK_SET))
10813         {
10814           error (_("Unable to seek to start of dynamic information\n"));
10815           goto no_gnu_hash;
10816         }
10817
10818       gnuchains = get_dynamic_data (file, maxchain, 4);
10819       ngnuchains = maxchain;
10820
10821     no_gnu_hash:
10822       if (gnuchains == NULL)
10823         {
10824           free (gnubuckets);
10825           gnubuckets = NULL;
10826           ngnubuckets = 0;
10827           if (do_using_dynamic)
10828             return 0;
10829         }
10830     }
10831
10832   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10833       && do_syms
10834       && do_using_dynamic
10835       && dynamic_strings != NULL
10836       && dynamic_symbols != NULL)
10837     {
10838       unsigned long hn;
10839
10840       if (dynamic_info[DT_HASH])
10841         {
10842           bfd_vma si;
10843
10844           printf (_("\nSymbol table for image:\n"));
10845           if (is_32bit_elf)
10846             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10847           else
10848             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10849
10850           for (hn = 0; hn < nbuckets; hn++)
10851             {
10852               if (! buckets[hn])
10853                 continue;
10854
10855               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10856                 print_dynamic_symbol (si, hn);
10857             }
10858         }
10859
10860       if (dynamic_info_DT_GNU_HASH)
10861         {
10862           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10863           if (is_32bit_elf)
10864             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10865           else
10866             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10867
10868           for (hn = 0; hn < ngnubuckets; ++hn)
10869             if (gnubuckets[hn] != 0)
10870               {
10871                 bfd_vma si = gnubuckets[hn];
10872                 bfd_vma off = si - gnusymidx;
10873
10874                 do
10875                   {
10876                     print_dynamic_symbol (si, hn);
10877                     si++;
10878                   }
10879                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10880               }
10881         }
10882     }
10883   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10884            && section_headers != NULL)
10885     {
10886       unsigned int i;
10887
10888       for (i = 0, section = section_headers;
10889            i < elf_header.e_shnum;
10890            i++, section++)
10891         {
10892           unsigned int si;
10893           char * strtab = NULL;
10894           unsigned long int strtab_size = 0;
10895           Elf_Internal_Sym * symtab;
10896           Elf_Internal_Sym * psym;
10897           unsigned long num_syms;
10898
10899           if ((section->sh_type != SHT_SYMTAB
10900                && section->sh_type != SHT_DYNSYM)
10901               || (!do_syms
10902                   && section->sh_type == SHT_SYMTAB))
10903             continue;
10904
10905           if (section->sh_entsize == 0)
10906             {
10907               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10908                       printable_section_name (section));
10909               continue;
10910             }
10911
10912           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10913                   printable_section_name (section),
10914                   (unsigned long) (section->sh_size / section->sh_entsize));
10915
10916           if (is_32bit_elf)
10917             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10918           else
10919             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10920
10921           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10922           if (symtab == NULL)
10923             continue;
10924
10925           if (section->sh_link == elf_header.e_shstrndx)
10926             {
10927               strtab = string_table;
10928               strtab_size = string_table_length;
10929             }
10930           else if (section->sh_link < elf_header.e_shnum)
10931             {
10932               Elf_Internal_Shdr * string_sec;
10933
10934               string_sec = section_headers + section->sh_link;
10935
10936               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10937                                           1, string_sec->sh_size,
10938                                           _("string table"));
10939               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10940             }
10941
10942           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10943             {
10944               const char *version_string;
10945               enum versioned_symbol_info sym_info;
10946               unsigned short vna_other;
10947
10948               printf ("%6d: ", si);
10949               print_vma (psym->st_value, LONG_HEX);
10950               putchar (' ');
10951               print_vma (psym->st_size, DEC_5);
10952               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10953               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10954               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10955               /* Check to see if any other bits in the st_other field are set.
10956                  Note - displaying this information disrupts the layout of the
10957                  table being generated, but for the moment this case is very rare.  */
10958               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10959                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10960               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10961               print_symbol (25, psym->st_name < strtab_size
10962                             ? strtab + psym->st_name : _("<corrupt>"));
10963
10964               version_string
10965                 = get_symbol_version_string (file,
10966                                              section->sh_type == SHT_DYNSYM,
10967                                              strtab, strtab_size, si,
10968                                              psym, &sym_info, &vna_other);
10969               if (version_string)
10970                 {
10971                   if (sym_info == symbol_undefined)
10972                     printf ("@%s (%d)", version_string, vna_other);
10973                   else
10974                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10975                             version_string);
10976                 }
10977
10978               putchar ('\n');
10979             }
10980
10981           free (symtab);
10982           if (strtab != string_table)
10983             free (strtab);
10984         }
10985     }
10986   else if (do_syms)
10987     printf
10988       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10989
10990   if (do_histogram && buckets != NULL)
10991     {
10992       unsigned long * lengths;
10993       unsigned long * counts;
10994       unsigned long hn;
10995       bfd_vma si;
10996       unsigned long maxlength = 0;
10997       unsigned long nzero_counts = 0;
10998       unsigned long nsyms = 0;
10999       unsigned long chained;
11000
11001       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11002               (unsigned long) nbuckets);
11003
11004       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11005       if (lengths == NULL)
11006         {
11007           error (_("Out of memory allocating space for histogram buckets\n"));
11008           return 0;
11009         }
11010
11011       printf (_(" Length  Number     %% of total  Coverage\n"));
11012       for (hn = 0; hn < nbuckets; ++hn)
11013         {
11014           for (si = buckets[hn], chained = 0;
11015                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11016                si = chains[si], ++chained)
11017             {
11018               ++nsyms;
11019               if (maxlength < ++lengths[hn])
11020                 ++maxlength;
11021             }
11022
11023             /* PR binutils/17531: A corrupt binary could contain broken
11024                histogram data.  Do not go into an infinite loop trying
11025                to process it.  */
11026             if (chained > nchains)
11027               {
11028                 error (_("histogram chain is corrupt\n"));
11029                 break;
11030               }
11031         }
11032
11033       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11034       if (counts == NULL)
11035         {
11036           free (lengths);
11037           error (_("Out of memory allocating space for histogram counts\n"));
11038           return 0;
11039         }
11040
11041       for (hn = 0; hn < nbuckets; ++hn)
11042         ++counts[lengths[hn]];
11043
11044       if (nbuckets > 0)
11045         {
11046           unsigned long i;
11047           printf ("      0  %-10lu (%5.1f%%)\n",
11048                   counts[0], (counts[0] * 100.0) / nbuckets);
11049           for (i = 1; i <= maxlength; ++i)
11050             {
11051               nzero_counts += counts[i] * i;
11052               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11053                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11054                       (nzero_counts * 100.0) / nsyms);
11055             }
11056         }
11057
11058       free (counts);
11059       free (lengths);
11060     }
11061
11062   if (buckets != NULL)
11063     {
11064       free (buckets);
11065       free (chains);
11066     }
11067
11068   if (do_histogram && gnubuckets != NULL)
11069     {
11070       unsigned long * lengths;
11071       unsigned long * counts;
11072       unsigned long hn;
11073       unsigned long maxlength = 0;
11074       unsigned long nzero_counts = 0;
11075       unsigned long nsyms = 0;
11076
11077       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11078               (unsigned long) ngnubuckets);
11079
11080       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11081       if (lengths == NULL)
11082         {
11083           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11084           return 0;
11085         }
11086
11087       printf (_(" Length  Number     %% of total  Coverage\n"));
11088
11089       for (hn = 0; hn < ngnubuckets; ++hn)
11090         if (gnubuckets[hn] != 0)
11091           {
11092             bfd_vma off, length = 1;
11093
11094             for (off = gnubuckets[hn] - gnusymidx;
11095                  /* PR 17531 file: 010-77222-0.004.  */
11096                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11097                  ++off)
11098               ++length;
11099             lengths[hn] = length;
11100             if (length > maxlength)
11101               maxlength = length;
11102             nsyms += length;
11103           }
11104
11105       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11106       if (counts == NULL)
11107         {
11108           free (lengths);
11109           error (_("Out of memory allocating space for gnu histogram counts\n"));
11110           return 0;
11111         }
11112
11113       for (hn = 0; hn < ngnubuckets; ++hn)
11114         ++counts[lengths[hn]];
11115
11116       if (ngnubuckets > 0)
11117         {
11118           unsigned long j;
11119           printf ("      0  %-10lu (%5.1f%%)\n",
11120                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11121           for (j = 1; j <= maxlength; ++j)
11122             {
11123               nzero_counts += counts[j] * j;
11124               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11125                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11126                       (nzero_counts * 100.0) / nsyms);
11127             }
11128         }
11129
11130       free (counts);
11131       free (lengths);
11132       free (gnubuckets);
11133       free (gnuchains);
11134     }
11135
11136   return 1;
11137 }
11138
11139 static int
11140 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11141 {
11142   unsigned int i;
11143
11144   if (dynamic_syminfo == NULL
11145       || !do_dynamic)
11146     /* No syminfo, this is ok.  */
11147     return 1;
11148
11149   /* There better should be a dynamic symbol section.  */
11150   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11151     return 0;
11152
11153   if (dynamic_addr)
11154     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11155             dynamic_syminfo_offset, dynamic_syminfo_nent);
11156
11157   printf (_(" Num: Name                           BoundTo     Flags\n"));
11158   for (i = 0; i < dynamic_syminfo_nent; ++i)
11159     {
11160       unsigned short int flags = dynamic_syminfo[i].si_flags;
11161
11162       printf ("%4d: ", i);
11163       if (i >= num_dynamic_syms)
11164         printf (_("<corrupt index>"));
11165       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11166         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11167       else
11168         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11169       putchar (' ');
11170
11171       switch (dynamic_syminfo[i].si_boundto)
11172         {
11173         case SYMINFO_BT_SELF:
11174           fputs ("SELF       ", stdout);
11175           break;
11176         case SYMINFO_BT_PARENT:
11177           fputs ("PARENT     ", stdout);
11178           break;
11179         default:
11180           if (dynamic_syminfo[i].si_boundto > 0
11181               && dynamic_syminfo[i].si_boundto < dynamic_nent
11182               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11183             {
11184               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11185               putchar (' ' );
11186             }
11187           else
11188             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11189           break;
11190         }
11191
11192       if (flags & SYMINFO_FLG_DIRECT)
11193         printf (" DIRECT");
11194       if (flags & SYMINFO_FLG_PASSTHRU)
11195         printf (" PASSTHRU");
11196       if (flags & SYMINFO_FLG_COPY)
11197         printf (" COPY");
11198       if (flags & SYMINFO_FLG_LAZYLOAD)
11199         printf (" LAZYLOAD");
11200
11201       puts ("");
11202     }
11203
11204   return 1;
11205 }
11206
11207 /* Check to see if the given reloc needs to be handled in a target specific
11208    manner.  If so then process the reloc and return TRUE otherwise return
11209    FALSE.  */
11210
11211 static bfd_boolean
11212 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11213                                 unsigned char *     start,
11214                                 Elf_Internal_Sym *  symtab)
11215 {
11216   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11217
11218   switch (elf_header.e_machine)
11219     {
11220     case EM_MSP430:
11221     case EM_MSP430_OLD:
11222       {
11223         static Elf_Internal_Sym * saved_sym = NULL;
11224
11225         switch (reloc_type)
11226           {
11227           case 10: /* R_MSP430_SYM_DIFF */
11228             if (uses_msp430x_relocs ())
11229               break;
11230           case 21: /* R_MSP430X_SYM_DIFF */
11231             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11232             return TRUE;
11233
11234           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11235           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11236             goto handle_sym_diff;
11237
11238           case 5: /* R_MSP430_16_BYTE */
11239           case 9: /* R_MSP430_8 */
11240             if (uses_msp430x_relocs ())
11241               break;
11242             goto handle_sym_diff;
11243
11244           case 2: /* R_MSP430_ABS16 */
11245           case 15: /* R_MSP430X_ABS16 */
11246             if (! uses_msp430x_relocs ())
11247               break;
11248             goto handle_sym_diff;
11249
11250           handle_sym_diff:
11251             if (saved_sym != NULL)
11252               {
11253                 bfd_vma value;
11254
11255                 value = reloc->r_addend
11256                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11257                      - saved_sym->st_value);
11258
11259                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11260
11261                 saved_sym = NULL;
11262                 return TRUE;
11263               }
11264             break;
11265
11266           default:
11267             if (saved_sym != NULL)
11268               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11269             break;
11270           }
11271         break;
11272       }
11273
11274     case EM_MN10300:
11275     case EM_CYGNUS_MN10300:
11276       {
11277         static Elf_Internal_Sym * saved_sym = NULL;
11278
11279         switch (reloc_type)
11280           {
11281           case 34: /* R_MN10300_ALIGN */
11282             return TRUE;
11283           case 33: /* R_MN10300_SYM_DIFF */
11284             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11285             return TRUE;
11286           case 1: /* R_MN10300_32 */
11287           case 2: /* R_MN10300_16 */
11288             if (saved_sym != NULL)
11289               {
11290                 bfd_vma value;
11291
11292                 value = reloc->r_addend
11293                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11294                      - saved_sym->st_value);
11295
11296                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11297
11298                 saved_sym = NULL;
11299                 return TRUE;
11300               }
11301             break;
11302           default:
11303             if (saved_sym != NULL)
11304               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11305             break;
11306           }
11307         break;
11308       }
11309
11310     case EM_RL78:
11311       {
11312         static bfd_vma saved_sym1 = 0;
11313         static bfd_vma saved_sym2 = 0;
11314         static bfd_vma value;
11315
11316         switch (reloc_type)
11317           {
11318           case 0x80: /* R_RL78_SYM.  */
11319             saved_sym1 = saved_sym2;
11320             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11321             saved_sym2 += reloc->r_addend;
11322             return TRUE;
11323
11324           case 0x83: /* R_RL78_OPsub.  */
11325             value = saved_sym1 - saved_sym2;
11326             saved_sym2 = saved_sym1 = 0;
11327             return TRUE;
11328             break;
11329
11330           case 0x41: /* R_RL78_ABS32.  */
11331             byte_put (start + reloc->r_offset, value, 4);
11332             value = 0;
11333             return TRUE;
11334
11335           case 0x43: /* R_RL78_ABS16.  */
11336             byte_put (start + reloc->r_offset, value, 2);
11337             value = 0;
11338             return TRUE;
11339
11340           default:
11341             break;
11342           }
11343         break;
11344       }
11345     }
11346
11347   return FALSE;
11348 }
11349
11350 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11351    DWARF debug sections.  This is a target specific test.  Note - we do not
11352    go through the whole including-target-headers-multiple-times route, (as
11353    we have already done with <elf/h8.h>) because this would become very
11354    messy and even then this function would have to contain target specific
11355    information (the names of the relocs instead of their numeric values).
11356    FIXME: This is not the correct way to solve this problem.  The proper way
11357    is to have target specific reloc sizing and typing functions created by
11358    the reloc-macros.h header, in the same way that it already creates the
11359    reloc naming functions.  */
11360
11361 static bfd_boolean
11362 is_32bit_abs_reloc (unsigned int reloc_type)
11363 {
11364   switch (elf_header.e_machine)
11365     {
11366     case EM_386:
11367     case EM_IAMCU:
11368       return reloc_type == 1; /* R_386_32.  */
11369     case EM_68K:
11370       return reloc_type == 1; /* R_68K_32.  */
11371     case EM_860:
11372       return reloc_type == 1; /* R_860_32.  */
11373     case EM_960:
11374       return reloc_type == 2; /* R_960_32.  */
11375     case EM_AARCH64:
11376       return reloc_type == 258; /* R_AARCH64_ABS32 */
11377     case EM_ALPHA:
11378       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11379     case EM_ARC:
11380       return reloc_type == 1; /* R_ARC_32.  */
11381     case EM_ARC_COMPACT:
11382     case EM_ARC_COMPACT2:
11383       return reloc_type == 4; /* R_ARC_32.  */
11384     case EM_ARM:
11385       return reloc_type == 2; /* R_ARM_ABS32 */
11386     case EM_AVR_OLD:
11387     case EM_AVR:
11388       return reloc_type == 1;
11389     case EM_ADAPTEVA_EPIPHANY:
11390       return reloc_type == 3;
11391     case EM_BLACKFIN:
11392       return reloc_type == 0x12; /* R_byte4_data.  */
11393     case EM_CRIS:
11394       return reloc_type == 3; /* R_CRIS_32.  */
11395     case EM_CR16:
11396       return reloc_type == 3; /* R_CR16_NUM32.  */
11397     case EM_CRX:
11398       return reloc_type == 15; /* R_CRX_NUM32.  */
11399     case EM_CYGNUS_FRV:
11400       return reloc_type == 1;
11401     case EM_CYGNUS_D10V:
11402     case EM_D10V:
11403       return reloc_type == 6; /* R_D10V_32.  */
11404     case EM_CYGNUS_D30V:
11405     case EM_D30V:
11406       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11407     case EM_DLX:
11408       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11409     case EM_CYGNUS_FR30:
11410     case EM_FR30:
11411       return reloc_type == 3; /* R_FR30_32.  */
11412     case EM_FT32:
11413       return reloc_type == 1; /* R_FT32_32.  */
11414     case EM_H8S:
11415     case EM_H8_300:
11416     case EM_H8_300H:
11417       return reloc_type == 1; /* R_H8_DIR32.  */
11418     case EM_IA_64:
11419       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11420         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11421     case EM_IP2K_OLD:
11422     case EM_IP2K:
11423       return reloc_type == 2; /* R_IP2K_32.  */
11424     case EM_IQ2000:
11425       return reloc_type == 2; /* R_IQ2000_32.  */
11426     case EM_LATTICEMICO32:
11427       return reloc_type == 3; /* R_LM32_32.  */
11428     case EM_M32C_OLD:
11429     case EM_M32C:
11430       return reloc_type == 3; /* R_M32C_32.  */
11431     case EM_M32R:
11432       return reloc_type == 34; /* R_M32R_32_RELA.  */
11433     case EM_68HC11:
11434     case EM_68HC12:
11435       return reloc_type == 6; /* R_M68HC11_32.  */
11436     case EM_MCORE:
11437       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11438     case EM_CYGNUS_MEP:
11439       return reloc_type == 4; /* R_MEP_32.  */
11440     case EM_METAG:
11441       return reloc_type == 2; /* R_METAG_ADDR32.  */
11442     case EM_MICROBLAZE:
11443       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11444     case EM_MIPS:
11445       return reloc_type == 2; /* R_MIPS_32.  */
11446     case EM_MMIX:
11447       return reloc_type == 4; /* R_MMIX_32.  */
11448     case EM_CYGNUS_MN10200:
11449     case EM_MN10200:
11450       return reloc_type == 1; /* R_MN10200_32.  */
11451     case EM_CYGNUS_MN10300:
11452     case EM_MN10300:
11453       return reloc_type == 1; /* R_MN10300_32.  */
11454     case EM_MOXIE:
11455       return reloc_type == 1; /* R_MOXIE_32.  */
11456     case EM_MSP430_OLD:
11457     case EM_MSP430:
11458       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11459     case EM_MT:
11460       return reloc_type == 2; /* R_MT_32.  */
11461     case EM_NDS32:
11462       return reloc_type == 20; /* R_NDS32_RELA.  */
11463     case EM_ALTERA_NIOS2:
11464       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11465     case EM_NIOS32:
11466       return reloc_type == 1; /* R_NIOS_32.  */
11467     case EM_OR1K:
11468       return reloc_type == 1; /* R_OR1K_32.  */
11469     case EM_PARISC:
11470       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11471               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11472     case EM_PJ:
11473     case EM_PJ_OLD:
11474       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11475     case EM_PPC64:
11476       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11477     case EM_PPC:
11478       return reloc_type == 1; /* R_PPC_ADDR32.  */
11479     case EM_RL78:
11480       return reloc_type == 1; /* R_RL78_DIR32.  */
11481     case EM_RX:
11482       return reloc_type == 1; /* R_RX_DIR32.  */
11483     case EM_S370:
11484       return reloc_type == 1; /* R_I370_ADDR31.  */
11485     case EM_S390_OLD:
11486     case EM_S390:
11487       return reloc_type == 4; /* R_S390_32.  */
11488     case EM_SCORE:
11489       return reloc_type == 8; /* R_SCORE_ABS32.  */
11490     case EM_SH:
11491       return reloc_type == 1; /* R_SH_DIR32.  */
11492     case EM_SPARC32PLUS:
11493     case EM_SPARCV9:
11494     case EM_SPARC:
11495       return reloc_type == 3 /* R_SPARC_32.  */
11496         || reloc_type == 23; /* R_SPARC_UA32.  */
11497     case EM_SPU:
11498       return reloc_type == 6; /* R_SPU_ADDR32 */
11499     case EM_TI_C6000:
11500       return reloc_type == 1; /* R_C6000_ABS32.  */
11501     case EM_TILEGX:
11502       return reloc_type == 2; /* R_TILEGX_32.  */
11503     case EM_TILEPRO:
11504       return reloc_type == 1; /* R_TILEPRO_32.  */
11505     case EM_CYGNUS_V850:
11506     case EM_V850:
11507       return reloc_type == 6; /* R_V850_ABS32.  */
11508     case EM_V800:
11509       return reloc_type == 0x33; /* R_V810_WORD.  */
11510     case EM_VAX:
11511       return reloc_type == 1; /* R_VAX_32.  */
11512     case EM_VISIUM:
11513       return reloc_type == 3;  /* R_VISIUM_32. */
11514     case EM_X86_64:
11515     case EM_L1OM:
11516     case EM_K1OM:
11517       return reloc_type == 10; /* R_X86_64_32.  */
11518     case EM_XC16X:
11519     case EM_C166:
11520       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11521     case EM_XGATE:
11522       return reloc_type == 4; /* R_XGATE_32.  */
11523     case EM_XSTORMY16:
11524       return reloc_type == 1; /* R_XSTROMY16_32.  */
11525     case EM_XTENSA_OLD:
11526     case EM_XTENSA:
11527       return reloc_type == 1; /* R_XTENSA_32.  */
11528     default:
11529       {
11530         static unsigned int prev_warn = 0;
11531
11532         /* Avoid repeating the same warning multiple times.  */
11533         if (prev_warn != elf_header.e_machine)
11534           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11535                  elf_header.e_machine);
11536         prev_warn = elf_header.e_machine;
11537         return FALSE;
11538       }
11539     }
11540 }
11541
11542 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11543    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11544
11545 static bfd_boolean
11546 is_32bit_pcrel_reloc (unsigned int reloc_type)
11547 {
11548   switch (elf_header.e_machine)
11549     {
11550     case EM_386:
11551     case EM_IAMCU:
11552       return reloc_type == 2;  /* R_386_PC32.  */
11553     case EM_68K:
11554       return reloc_type == 4;  /* R_68K_PC32.  */
11555     case EM_AARCH64:
11556       return reloc_type == 261; /* R_AARCH64_PREL32 */
11557     case EM_ADAPTEVA_EPIPHANY:
11558       return reloc_type == 6;
11559     case EM_ALPHA:
11560       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11561     case EM_ARC_COMPACT:
11562     case EM_ARC_COMPACT2:
11563       return reloc_type == 49; /* R_ARC_32_PCREL.  */
11564     case EM_ARM:
11565       return reloc_type == 3;  /* R_ARM_REL32 */
11566     case EM_MICROBLAZE:
11567       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11568     case EM_OR1K:
11569       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11570     case EM_PARISC:
11571       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11572     case EM_PPC:
11573       return reloc_type == 26; /* R_PPC_REL32.  */
11574     case EM_PPC64:
11575       return reloc_type == 26; /* R_PPC64_REL32.  */
11576     case EM_S390_OLD:
11577     case EM_S390:
11578       return reloc_type == 5;  /* R_390_PC32.  */
11579     case EM_SH:
11580       return reloc_type == 2;  /* R_SH_REL32.  */
11581     case EM_SPARC32PLUS:
11582     case EM_SPARCV9:
11583     case EM_SPARC:
11584       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11585     case EM_SPU:
11586       return reloc_type == 13; /* R_SPU_REL32.  */
11587     case EM_TILEGX:
11588       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11589     case EM_TILEPRO:
11590       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11591     case EM_VISIUM:
11592       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11593     case EM_X86_64:
11594     case EM_L1OM:
11595     case EM_K1OM:
11596       return reloc_type == 2;  /* R_X86_64_PC32.  */
11597     case EM_XTENSA_OLD:
11598     case EM_XTENSA:
11599       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11600     default:
11601       /* Do not abort or issue an error message here.  Not all targets use
11602          pc-relative 32-bit relocs in their DWARF debug information and we
11603          have already tested for target coverage in is_32bit_abs_reloc.  A
11604          more helpful warning message will be generated by apply_relocations
11605          anyway, so just return.  */
11606       return FALSE;
11607     }
11608 }
11609
11610 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11611    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11612
11613 static bfd_boolean
11614 is_64bit_abs_reloc (unsigned int reloc_type)
11615 {
11616   switch (elf_header.e_machine)
11617     {
11618     case EM_AARCH64:
11619       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11620     case EM_ALPHA:
11621       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11622     case EM_IA_64:
11623       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11624     case EM_PARISC:
11625       return reloc_type == 80; /* R_PARISC_DIR64.  */
11626     case EM_PPC64:
11627       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11628     case EM_SPARC32PLUS:
11629     case EM_SPARCV9:
11630     case EM_SPARC:
11631       return reloc_type == 54; /* R_SPARC_UA64.  */
11632     case EM_X86_64:
11633     case EM_L1OM:
11634     case EM_K1OM:
11635       return reloc_type == 1; /* R_X86_64_64.  */
11636     case EM_S390_OLD:
11637     case EM_S390:
11638       return reloc_type == 22;  /* R_S390_64.  */
11639     case EM_TILEGX:
11640       return reloc_type == 1; /* R_TILEGX_64.  */
11641     case EM_MIPS:
11642       return reloc_type == 18;  /* R_MIPS_64.  */
11643     default:
11644       return FALSE;
11645     }
11646 }
11647
11648 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11649    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11650
11651 static bfd_boolean
11652 is_64bit_pcrel_reloc (unsigned int reloc_type)
11653 {
11654   switch (elf_header.e_machine)
11655     {
11656     case EM_AARCH64:
11657       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11658     case EM_ALPHA:
11659       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11660     case EM_IA_64:
11661       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11662     case EM_PARISC:
11663       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11664     case EM_PPC64:
11665       return reloc_type == 44; /* R_PPC64_REL64.  */
11666     case EM_SPARC32PLUS:
11667     case EM_SPARCV9:
11668     case EM_SPARC:
11669       return reloc_type == 46; /* R_SPARC_DISP64.  */
11670     case EM_X86_64:
11671     case EM_L1OM:
11672     case EM_K1OM:
11673       return reloc_type == 24; /* R_X86_64_PC64.  */
11674     case EM_S390_OLD:
11675     case EM_S390:
11676       return reloc_type == 23;  /* R_S390_PC64.  */
11677     case EM_TILEGX:
11678       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11679     default:
11680       return FALSE;
11681     }
11682 }
11683
11684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11685    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11686
11687 static bfd_boolean
11688 is_24bit_abs_reloc (unsigned int reloc_type)
11689 {
11690   switch (elf_header.e_machine)
11691     {
11692     case EM_CYGNUS_MN10200:
11693     case EM_MN10200:
11694       return reloc_type == 4; /* R_MN10200_24.  */
11695     default:
11696       return FALSE;
11697     }
11698 }
11699
11700 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11701    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11702
11703 static bfd_boolean
11704 is_16bit_abs_reloc (unsigned int reloc_type)
11705 {
11706   switch (elf_header.e_machine)
11707     {
11708     case EM_ARC:
11709     case EM_ARC_COMPACT:
11710     case EM_ARC_COMPACT2:
11711       return reloc_type == 2; /* R_ARC_16.  */
11712     case EM_AVR_OLD:
11713     case EM_AVR:
11714       return reloc_type == 4; /* R_AVR_16.  */
11715     case EM_ADAPTEVA_EPIPHANY:
11716       return reloc_type == 5;
11717     case EM_CYGNUS_D10V:
11718     case EM_D10V:
11719       return reloc_type == 3; /* R_D10V_16.  */
11720     case EM_H8S:
11721     case EM_H8_300:
11722     case EM_H8_300H:
11723       return reloc_type == R_H8_DIR16;
11724     case EM_IP2K_OLD:
11725     case EM_IP2K:
11726       return reloc_type == 1; /* R_IP2K_16.  */
11727     case EM_M32C_OLD:
11728     case EM_M32C:
11729       return reloc_type == 1; /* R_M32C_16 */
11730     case EM_MSP430:
11731       if (uses_msp430x_relocs ())
11732         return reloc_type == 2; /* R_MSP430_ABS16.  */
11733     case EM_MSP430_OLD:
11734       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11735     case EM_NDS32:
11736       return reloc_type == 19; /* R_NDS32_RELA.  */
11737     case EM_ALTERA_NIOS2:
11738       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11739     case EM_NIOS32:
11740       return reloc_type == 9; /* R_NIOS_16.  */
11741     case EM_OR1K:
11742       return reloc_type == 2; /* R_OR1K_16.  */
11743     case EM_TI_C6000:
11744       return reloc_type == 2; /* R_C6000_ABS16.  */
11745     case EM_XC16X:
11746     case EM_C166:
11747       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11748     case EM_CYGNUS_MN10200:
11749     case EM_MN10200:
11750       return reloc_type == 2; /* R_MN10200_16.  */
11751     case EM_CYGNUS_MN10300:
11752     case EM_MN10300:
11753       return reloc_type == 2; /* R_MN10300_16.  */
11754     case EM_VISIUM:
11755       return reloc_type == 2; /* R_VISIUM_16. */
11756     case EM_XGATE:
11757       return reloc_type == 3; /* R_XGATE_16.  */
11758     default:
11759       return FALSE;
11760     }
11761 }
11762
11763 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11764    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11765
11766 static bfd_boolean
11767 is_none_reloc (unsigned int reloc_type)
11768 {
11769   switch (elf_header.e_machine)
11770     {
11771     case EM_68K:     /* R_68K_NONE.  */
11772     case EM_386:     /* R_386_NONE.  */
11773     case EM_SPARC32PLUS:
11774     case EM_SPARCV9:
11775     case EM_SPARC:   /* R_SPARC_NONE.  */
11776     case EM_MIPS:    /* R_MIPS_NONE.  */
11777     case EM_PARISC:  /* R_PARISC_NONE.  */
11778     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11779     case EM_ADAPTEVA_EPIPHANY:
11780     case EM_PPC:     /* R_PPC_NONE.  */
11781     case EM_PPC64:   /* R_PPC64_NONE.  */
11782     case EM_ARC:     /* R_ARC_NONE.  */
11783     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
11784     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
11785     case EM_ARM:     /* R_ARM_NONE.  */
11786     case EM_IA_64:   /* R_IA64_NONE.  */
11787     case EM_SH:      /* R_SH_NONE.  */
11788     case EM_S390_OLD:
11789     case EM_S390:    /* R_390_NONE.  */
11790     case EM_CRIS:    /* R_CRIS_NONE.  */
11791     case EM_X86_64:  /* R_X86_64_NONE.  */
11792     case EM_L1OM:    /* R_X86_64_NONE.  */
11793     case EM_K1OM:    /* R_X86_64_NONE.  */
11794     case EM_MN10300: /* R_MN10300_NONE.  */
11795     case EM_FT32:    /* R_FT32_NONE.  */
11796     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11797     case EM_M32R:    /* R_M32R_NONE.  */
11798     case EM_TI_C6000:/* R_C6000_NONE.  */
11799     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11800     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11801     case EM_XC16X:
11802     case EM_C166:    /* R_XC16X_NONE.  */
11803     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11804     case EM_NIOS32:  /* R_NIOS_NONE.  */
11805     case EM_OR1K:    /* R_OR1K_NONE. */
11806       return reloc_type == 0;
11807     case EM_AARCH64:
11808       return reloc_type == 0 || reloc_type == 256;
11809     case EM_NDS32:
11810       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11811               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11812               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11813               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11814               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11815     case EM_XTENSA_OLD:
11816     case EM_XTENSA:
11817       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11818               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11819               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11820               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11821     case EM_METAG:
11822       return reloc_type == 3; /* R_METAG_NONE.  */
11823     }
11824   return FALSE;
11825 }
11826
11827 /* Returns TRUE if there is a relocation against
11828    section NAME at OFFSET bytes.  */
11829
11830 bfd_boolean
11831 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11832 {
11833   Elf_Internal_Rela * relocs;
11834   Elf_Internal_Rela * rp;
11835
11836   if (dsec == NULL || dsec->reloc_info == NULL)
11837     return FALSE;
11838
11839   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11840
11841   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11842     if (rp->r_offset == offset)
11843       return TRUE;
11844
11845    return FALSE;
11846 }
11847
11848 /* Apply relocations to a section.
11849    Note: So far support has been added only for those relocations
11850    which can be found in debug sections.
11851    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11852    loaded relocs.  It is then the caller's responsibility to free them.
11853    FIXME: Add support for more relocations ?  */
11854
11855 static void
11856 apply_relocations (void *                     file,
11857                    const Elf_Internal_Shdr *  section,
11858                    unsigned char *            start,
11859                    bfd_size_type              size,
11860                    void **                     relocs_return,
11861                    unsigned long *            num_relocs_return)
11862 {
11863   Elf_Internal_Shdr * relsec;
11864   unsigned char * end = start + size;
11865
11866   if (relocs_return != NULL)
11867     {
11868       * (Elf_Internal_Rela **) relocs_return = NULL;
11869       * num_relocs_return = 0;
11870     }
11871
11872   if (elf_header.e_type != ET_REL)
11873     return;
11874
11875   /* Find the reloc section associated with the section.  */
11876   for (relsec = section_headers;
11877        relsec < section_headers + elf_header.e_shnum;
11878        ++relsec)
11879     {
11880       bfd_boolean is_rela;
11881       unsigned long num_relocs;
11882       Elf_Internal_Rela * relocs;
11883       Elf_Internal_Rela * rp;
11884       Elf_Internal_Shdr * symsec;
11885       Elf_Internal_Sym * symtab;
11886       unsigned long num_syms;
11887       Elf_Internal_Sym * sym;
11888
11889       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11890           || relsec->sh_info >= elf_header.e_shnum
11891           || section_headers + relsec->sh_info != section
11892           || relsec->sh_size == 0
11893           || relsec->sh_link >= elf_header.e_shnum)
11894         continue;
11895
11896       is_rela = relsec->sh_type == SHT_RELA;
11897
11898       if (is_rela)
11899         {
11900           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11901                                   relsec->sh_size, & relocs, & num_relocs))
11902             return;
11903         }
11904       else
11905         {
11906           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11907                                  relsec->sh_size, & relocs, & num_relocs))
11908             return;
11909         }
11910
11911       /* SH uses RELA but uses in place value instead of the addend field.  */
11912       if (elf_header.e_machine == EM_SH)
11913         is_rela = FALSE;
11914
11915       symsec = section_headers + relsec->sh_link;
11916       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11917
11918       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11919         {
11920           bfd_vma         addend;
11921           unsigned int    reloc_type;
11922           unsigned int    reloc_size;
11923           unsigned char * rloc;
11924           unsigned long   sym_index;
11925
11926           reloc_type = get_reloc_type (rp->r_info);
11927
11928           if (target_specific_reloc_handling (rp, start, symtab))
11929             continue;
11930           else if (is_none_reloc (reloc_type))
11931             continue;
11932           else if (is_32bit_abs_reloc (reloc_type)
11933                    || is_32bit_pcrel_reloc (reloc_type))
11934             reloc_size = 4;
11935           else if (is_64bit_abs_reloc (reloc_type)
11936                    || is_64bit_pcrel_reloc (reloc_type))
11937             reloc_size = 8;
11938           else if (is_24bit_abs_reloc (reloc_type))
11939             reloc_size = 3;
11940           else if (is_16bit_abs_reloc (reloc_type))
11941             reloc_size = 2;
11942           else
11943             {
11944               static unsigned int prev_reloc = 0;
11945               if (reloc_type != prev_reloc)
11946                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11947                       reloc_type, printable_section_name (section));
11948               prev_reloc = reloc_type;
11949               continue;
11950             }
11951
11952           rloc = start + rp->r_offset;
11953           if ((rloc + reloc_size) > end || (rloc < start))
11954             {
11955               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11956                     (unsigned long) rp->r_offset,
11957                     printable_section_name (section));
11958               continue;
11959             }
11960
11961           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11962           if (sym_index >= num_syms)
11963             {
11964               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11965                     sym_index, printable_section_name (section));
11966               continue;
11967             }
11968           sym = symtab + sym_index;
11969
11970           /* If the reloc has a symbol associated with it,
11971              make sure that it is of an appropriate type.
11972
11973              Relocations against symbols without type can happen.
11974              Gcc -feliminate-dwarf2-dups may generate symbols
11975              without type for debug info.
11976
11977              Icc generates relocations against function symbols
11978              instead of local labels.
11979
11980              Relocations against object symbols can happen, eg when
11981              referencing a global array.  For an example of this see
11982              the _clz.o binary in libgcc.a.  */
11983           if (sym != symtab
11984               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11985             {
11986               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11987                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11988                     (long int)(rp - relocs),
11989                     printable_section_name (relsec));
11990               continue;
11991             }
11992
11993           addend = 0;
11994           if (is_rela)
11995             addend += rp->r_addend;
11996           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11997              partial_inplace.  */
11998           if (!is_rela
11999               || (elf_header.e_machine == EM_XTENSA
12000                   && reloc_type == 1)
12001               || ((elf_header.e_machine == EM_PJ
12002                    || elf_header.e_machine == EM_PJ_OLD)
12003                   && reloc_type == 1)
12004               || ((elf_header.e_machine == EM_D30V
12005                    || elf_header.e_machine == EM_CYGNUS_D30V)
12006                   && reloc_type == 12))
12007             addend += byte_get (rloc, reloc_size);
12008
12009           if (is_32bit_pcrel_reloc (reloc_type)
12010               || is_64bit_pcrel_reloc (reloc_type))
12011             {
12012               /* On HPPA, all pc-relative relocations are biased by 8.  */
12013               if (elf_header.e_machine == EM_PARISC)
12014                 addend -= 8;
12015               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12016                         reloc_size);
12017             }
12018           else
12019             byte_put (rloc, addend + sym->st_value, reloc_size);
12020         }
12021
12022       free (symtab);
12023
12024       if (relocs_return)
12025         {
12026           * (Elf_Internal_Rela **) relocs_return = relocs;
12027           * num_relocs_return = num_relocs;
12028         }
12029       else
12030         free (relocs);
12031
12032       break;
12033     }
12034 }
12035
12036 #ifdef SUPPORT_DISASSEMBLY
12037 static int
12038 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12039 {
12040   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12041
12042   /* FIXME: XXX -- to be done --- XXX */
12043
12044   return 1;
12045 }
12046 #endif
12047
12048 /* Reads in the contents of SECTION from FILE, returning a pointer
12049    to a malloc'ed buffer or NULL if something went wrong.  */
12050
12051 static char *
12052 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12053 {
12054   bfd_size_type num_bytes;
12055
12056   num_bytes = section->sh_size;
12057
12058   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12059     {
12060       printf (_("\nSection '%s' has no data to dump.\n"),
12061               printable_section_name (section));
12062       return NULL;
12063     }
12064
12065   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12066                              _("section contents"));
12067 }
12068
12069 /* Uncompresses a section that was compressed using zlib, in place.  */
12070
12071 static bfd_boolean
12072 uncompress_section_contents (unsigned char **buffer,
12073                              dwarf_size_type uncompressed_size,
12074                              dwarf_size_type *size)
12075 {
12076   dwarf_size_type compressed_size = *size;
12077   unsigned char * compressed_buffer = *buffer;
12078   unsigned char * uncompressed_buffer;
12079   z_stream strm;
12080   int rc;
12081
12082   /* It is possible the section consists of several compressed
12083      buffers concatenated together, so we uncompress in a loop.  */
12084   /* PR 18313: The state field in the z_stream structure is supposed
12085      to be invisible to the user (ie us), but some compilers will
12086      still complain about it being used without initialisation.  So
12087      we first zero the entire z_stream structure and then set the fields
12088      that we need.  */
12089   memset (& strm, 0, sizeof strm);
12090   strm.avail_in = compressed_size;
12091   strm.next_in = (Bytef *) compressed_buffer;
12092   strm.avail_out = uncompressed_size;
12093   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12094
12095   rc = inflateInit (& strm);
12096   while (strm.avail_in > 0)
12097     {
12098       if (rc != Z_OK)
12099         goto fail;
12100       strm.next_out = ((Bytef *) uncompressed_buffer
12101                        + (uncompressed_size - strm.avail_out));
12102       rc = inflate (&strm, Z_FINISH);
12103       if (rc != Z_STREAM_END)
12104         goto fail;
12105       rc = inflateReset (& strm);
12106     }
12107   rc = inflateEnd (& strm);
12108   if (rc != Z_OK
12109       || strm.avail_out != 0)
12110     goto fail;
12111
12112   *buffer = uncompressed_buffer;
12113   *size = uncompressed_size;
12114   return TRUE;
12115
12116  fail:
12117   free (uncompressed_buffer);
12118   /* Indicate decompression failure.  */
12119   *buffer = NULL;
12120   return FALSE;
12121 }
12122
12123 static void
12124 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12125 {
12126   Elf_Internal_Shdr *  relsec;
12127   bfd_size_type        num_bytes;
12128   unsigned char *      data;
12129   unsigned char *      end;
12130   unsigned char *      real_start;
12131   unsigned char *      start;
12132   bfd_boolean          some_strings_shown;
12133
12134   real_start = start = (unsigned char *) get_section_contents (section,
12135                                                                file);
12136   if (start == NULL)
12137     return;
12138   num_bytes = section->sh_size;
12139
12140   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12141
12142   if (decompress_dumps)
12143     {
12144       dwarf_size_type new_size = num_bytes;
12145       dwarf_size_type uncompressed_size = 0;
12146
12147       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12148         {
12149           Elf_Internal_Chdr chdr;
12150           unsigned int compression_header_size
12151             = get_compression_header (& chdr, (unsigned char *) start);
12152
12153           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12154             {
12155               warn (_("section '%s' has unsupported compress type: %d\n"),
12156                     printable_section_name (section), chdr.ch_type);
12157               return;
12158             }
12159           else if (chdr.ch_addralign != section->sh_addralign)
12160             {
12161               warn (_("compressed section '%s' is corrupted\n"),
12162                     printable_section_name (section));
12163               return;
12164             }
12165           uncompressed_size = chdr.ch_size;
12166           start += compression_header_size;
12167           new_size -= compression_header_size;
12168         }
12169       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12170         {
12171           /* Read the zlib header.  In this case, it should be "ZLIB"
12172              followed by the uncompressed section size, 8 bytes in
12173              big-endian order.  */
12174           uncompressed_size = start[4]; uncompressed_size <<= 8;
12175           uncompressed_size += start[5]; uncompressed_size <<= 8;
12176           uncompressed_size += start[6]; uncompressed_size <<= 8;
12177           uncompressed_size += start[7]; uncompressed_size <<= 8;
12178           uncompressed_size += start[8]; uncompressed_size <<= 8;
12179           uncompressed_size += start[9]; uncompressed_size <<= 8;
12180           uncompressed_size += start[10]; uncompressed_size <<= 8;
12181           uncompressed_size += start[11];
12182           start += 12;
12183           new_size -= 12;
12184         }
12185
12186       if (uncompressed_size
12187           && uncompress_section_contents (& start,
12188                                           uncompressed_size, & new_size))
12189         num_bytes = new_size;
12190     }
12191
12192   /* If the section being dumped has relocations against it the user might
12193      be expecting these relocations to have been applied.  Check for this
12194      case and issue a warning message in order to avoid confusion.
12195      FIXME: Maybe we ought to have an option that dumps a section with
12196      relocs applied ?  */
12197   for (relsec = section_headers;
12198        relsec < section_headers + elf_header.e_shnum;
12199        ++relsec)
12200     {
12201       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12202           || relsec->sh_info >= elf_header.e_shnum
12203           || section_headers + relsec->sh_info != section
12204           || relsec->sh_size == 0
12205           || relsec->sh_link >= elf_header.e_shnum)
12206         continue;
12207
12208       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12209       break;
12210     }
12211
12212   data = start;
12213   end  = start + num_bytes;
12214   some_strings_shown = FALSE;
12215
12216   while (data < end)
12217     {
12218       while (!ISPRINT (* data))
12219         if (++ data >= end)
12220           break;
12221
12222       if (data < end)
12223         {
12224           size_t maxlen = end - data;
12225
12226 #ifndef __MSVCRT__
12227           /* PR 11128: Use two separate invocations in order to work
12228              around bugs in the Solaris 8 implementation of printf.  */
12229           printf ("  [%6tx]  ", data - start);
12230 #else
12231           printf ("  [%6Ix]  ", (size_t) (data - start));
12232 #endif
12233           if (maxlen > 0)
12234             {
12235               print_symbol ((int) maxlen, (const char *) data);
12236               putchar ('\n');
12237               data += strnlen ((const char *) data, maxlen);
12238             }
12239           else
12240             {
12241               printf (_("<corrupt>\n"));
12242               data = end;
12243             }
12244           some_strings_shown = TRUE;
12245         }
12246     }
12247
12248   if (! some_strings_shown)
12249     printf (_("  No strings found in this section."));
12250
12251   free (real_start);
12252
12253   putchar ('\n');
12254 }
12255
12256 static void
12257 dump_section_as_bytes (Elf_Internal_Shdr * section,
12258                        FILE * file,
12259                        bfd_boolean relocate)
12260 {
12261   Elf_Internal_Shdr * relsec;
12262   bfd_size_type       bytes;
12263   bfd_size_type       section_size;
12264   bfd_vma             addr;
12265   unsigned char *     data;
12266   unsigned char *     real_start;
12267   unsigned char *     start;
12268
12269   real_start = start = (unsigned char *) get_section_contents (section, file);
12270   if (start == NULL)
12271     return;
12272   section_size = section->sh_size;
12273
12274   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12275
12276   if (decompress_dumps)
12277     {
12278       dwarf_size_type new_size = section_size;
12279       dwarf_size_type uncompressed_size = 0;
12280
12281       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12282         {
12283           Elf_Internal_Chdr chdr;
12284           unsigned int compression_header_size
12285             = get_compression_header (& chdr, start);
12286
12287           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12288             {
12289               warn (_("section '%s' has unsupported compress type: %d\n"),
12290                     printable_section_name (section), chdr.ch_type);
12291               return;
12292             }
12293           else if (chdr.ch_addralign != section->sh_addralign)
12294             {
12295               warn (_("compressed section '%s' is corrupted\n"),
12296                     printable_section_name (section));
12297               return;
12298             }
12299           uncompressed_size = chdr.ch_size;
12300           start += compression_header_size;
12301           new_size -= compression_header_size;
12302         }
12303       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12304         {
12305           /* Read the zlib header.  In this case, it should be "ZLIB"
12306              followed by the uncompressed section size, 8 bytes in
12307              big-endian order.  */
12308           uncompressed_size = start[4]; uncompressed_size <<= 8;
12309           uncompressed_size += start[5]; uncompressed_size <<= 8;
12310           uncompressed_size += start[6]; uncompressed_size <<= 8;
12311           uncompressed_size += start[7]; uncompressed_size <<= 8;
12312           uncompressed_size += start[8]; uncompressed_size <<= 8;
12313           uncompressed_size += start[9]; uncompressed_size <<= 8;
12314           uncompressed_size += start[10]; uncompressed_size <<= 8;
12315           uncompressed_size += start[11];
12316           start += 12;
12317           new_size -= 12;
12318         }
12319
12320       if (uncompressed_size
12321           && uncompress_section_contents (& start, uncompressed_size,
12322                                           & new_size))
12323         section_size = new_size;
12324     }
12325
12326   if (relocate)
12327     {
12328       apply_relocations (file, section, start, section_size, NULL, NULL);
12329     }
12330   else
12331     {
12332       /* If the section being dumped has relocations against it the user might
12333          be expecting these relocations to have been applied.  Check for this
12334          case and issue a warning message in order to avoid confusion.
12335          FIXME: Maybe we ought to have an option that dumps a section with
12336          relocs applied ?  */
12337       for (relsec = section_headers;
12338            relsec < section_headers + elf_header.e_shnum;
12339            ++relsec)
12340         {
12341           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12342               || relsec->sh_info >= elf_header.e_shnum
12343               || section_headers + relsec->sh_info != section
12344               || relsec->sh_size == 0
12345               || relsec->sh_link >= elf_header.e_shnum)
12346             continue;
12347
12348           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12349           break;
12350         }
12351     }
12352
12353   addr = section->sh_addr;
12354   bytes = section_size;
12355   data = start;
12356
12357   while (bytes)
12358     {
12359       int j;
12360       int k;
12361       int lbytes;
12362
12363       lbytes = (bytes > 16 ? 16 : bytes);
12364
12365       printf ("  0x%8.8lx ", (unsigned long) addr);
12366
12367       for (j = 0; j < 16; j++)
12368         {
12369           if (j < lbytes)
12370             printf ("%2.2x", data[j]);
12371           else
12372             printf ("  ");
12373
12374           if ((j & 3) == 3)
12375             printf (" ");
12376         }
12377
12378       for (j = 0; j < lbytes; j++)
12379         {
12380           k = data[j];
12381           if (k >= ' ' && k < 0x7f)
12382             printf ("%c", k);
12383           else
12384             printf (".");
12385         }
12386
12387       putchar ('\n');
12388
12389       data  += lbytes;
12390       addr  += lbytes;
12391       bytes -= lbytes;
12392     }
12393
12394   free (real_start);
12395
12396   putchar ('\n');
12397 }
12398
12399 static int
12400 load_specific_debug_section (enum dwarf_section_display_enum debug,
12401                              const Elf_Internal_Shdr * sec, void * file)
12402 {
12403   struct dwarf_section * section = &debug_displays [debug].section;
12404   char buf [64];
12405
12406   /* If it is already loaded, do nothing.  */
12407   if (section->start != NULL)
12408     return 1;
12409
12410   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12411   section->address = sec->sh_addr;
12412   section->user_data = NULL;
12413   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12414                                                sec->sh_offset, 1,
12415                                                sec->sh_size, buf);
12416   if (section->start == NULL)
12417     section->size = 0;
12418   else
12419     {
12420       unsigned char *start = section->start;
12421       dwarf_size_type size = sec->sh_size;
12422       dwarf_size_type uncompressed_size = 0;
12423
12424       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12425         {
12426           Elf_Internal_Chdr chdr;
12427           unsigned int compression_header_size
12428             = get_compression_header (&chdr, start);
12429           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12430             {
12431               warn (_("section '%s' has unsupported compress type: %d\n"),
12432                     section->name, chdr.ch_type);
12433               return 0;
12434             }
12435           else if (chdr.ch_addralign != sec->sh_addralign)
12436             {
12437               warn (_("compressed section '%s' is corrupted\n"),
12438                     section->name);
12439               return 0;
12440             }
12441           uncompressed_size = chdr.ch_size;
12442           start += compression_header_size;
12443           size -= compression_header_size;
12444         }
12445       else if (size > 12 && streq ((char *) start, "ZLIB"))
12446         {
12447           /* Read the zlib header.  In this case, it should be "ZLIB"
12448              followed by the uncompressed section size, 8 bytes in
12449              big-endian order.  */
12450           uncompressed_size = start[4]; uncompressed_size <<= 8;
12451           uncompressed_size += start[5]; uncompressed_size <<= 8;
12452           uncompressed_size += start[6]; uncompressed_size <<= 8;
12453           uncompressed_size += start[7]; uncompressed_size <<= 8;
12454           uncompressed_size += start[8]; uncompressed_size <<= 8;
12455           uncompressed_size += start[9]; uncompressed_size <<= 8;
12456           uncompressed_size += start[10]; uncompressed_size <<= 8;
12457           uncompressed_size += start[11];
12458           start += 12;
12459           size -= 12;
12460         }
12461
12462       if (uncompressed_size
12463           && uncompress_section_contents (&start, uncompressed_size,
12464                                           &size))
12465         {
12466           /* Free the compressed buffer, update the section buffer
12467              and the section size if uncompress is successful.  */
12468           free (section->start);
12469           section->start = start;
12470         }
12471       section->size = size;
12472     }
12473
12474   if (section->start == NULL)
12475     return 0;
12476
12477   if (debug_displays [debug].relocate)
12478     apply_relocations ((FILE *) file, sec, section->start, section->size,
12479                        & section->reloc_info, & section->num_relocs);
12480   else
12481     {
12482       section->reloc_info = NULL;
12483       section->num_relocs = 0;
12484     }
12485
12486   return 1;
12487 }
12488
12489 /* If this is not NULL, load_debug_section will only look for sections
12490    within the list of sections given here.  */
12491 unsigned int *section_subset = NULL;
12492
12493 int
12494 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12495 {
12496   struct dwarf_section * section = &debug_displays [debug].section;
12497   Elf_Internal_Shdr * sec;
12498
12499   /* Locate the debug section.  */
12500   sec = find_section_in_set (section->uncompressed_name, section_subset);
12501   if (sec != NULL)
12502     section->name = section->uncompressed_name;
12503   else
12504     {
12505       sec = find_section_in_set (section->compressed_name, section_subset);
12506       if (sec != NULL)
12507         section->name = section->compressed_name;
12508     }
12509   if (sec == NULL)
12510     return 0;
12511
12512   /* If we're loading from a subset of sections, and we've loaded
12513      a section matching this name before, it's likely that it's a
12514      different one.  */
12515   if (section_subset != NULL)
12516     free_debug_section (debug);
12517
12518   return load_specific_debug_section (debug, sec, (FILE *) file);
12519 }
12520
12521 void
12522 free_debug_section (enum dwarf_section_display_enum debug)
12523 {
12524   struct dwarf_section * section = &debug_displays [debug].section;
12525
12526   if (section->start == NULL)
12527     return;
12528
12529   free ((char *) section->start);
12530   section->start = NULL;
12531   section->address = 0;
12532   section->size = 0;
12533 }
12534
12535 static int
12536 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12537 {
12538   char * name = SECTION_NAME (section);
12539   const char * print_name = printable_section_name (section);
12540   bfd_size_type length;
12541   int result = 1;
12542   int i;
12543
12544   length = section->sh_size;
12545   if (length == 0)
12546     {
12547       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12548       return 0;
12549     }
12550   if (section->sh_type == SHT_NOBITS)
12551     {
12552       /* There is no point in dumping the contents of a debugging section
12553          which has the NOBITS type - the bits in the file will be random.
12554          This can happen when a file containing a .eh_frame section is
12555          stripped with the --only-keep-debug command line option.  */
12556       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12557               print_name);
12558       return 0;
12559     }
12560
12561   if (const_strneq (name, ".gnu.linkonce.wi."))
12562     name = ".debug_info";
12563
12564   /* See if we know how to display the contents of this section.  */
12565   for (i = 0; i < max; i++)
12566     if (streq (debug_displays[i].section.uncompressed_name, name)
12567         || (i == line && const_strneq (name, ".debug_line."))
12568         || streq (debug_displays[i].section.compressed_name, name))
12569       {
12570         struct dwarf_section * sec = &debug_displays [i].section;
12571         int secondary = (section != find_section (name));
12572
12573         if (secondary)
12574           free_debug_section ((enum dwarf_section_display_enum) i);
12575
12576         if (i == line && const_strneq (name, ".debug_line."))
12577           sec->name = name;
12578         else if (streq (sec->uncompressed_name, name))
12579           sec->name = sec->uncompressed_name;
12580         else
12581           sec->name = sec->compressed_name;
12582         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12583                                          section, file))
12584           {
12585             /* If this debug section is part of a CU/TU set in a .dwp file,
12586                restrict load_debug_section to the sections in that set.  */
12587             section_subset = find_cu_tu_set (file, shndx);
12588
12589             result &= debug_displays[i].display (sec, file);
12590
12591             section_subset = NULL;
12592
12593             if (secondary || (i != info && i != abbrev))
12594               free_debug_section ((enum dwarf_section_display_enum) i);
12595           }
12596
12597         break;
12598       }
12599
12600   if (i == max)
12601     {
12602       printf (_("Unrecognized debug section: %s\n"), print_name);
12603       result = 0;
12604     }
12605
12606   return result;
12607 }
12608
12609 /* Set DUMP_SECTS for all sections where dumps were requested
12610    based on section name.  */
12611
12612 static void
12613 initialise_dumps_byname (void)
12614 {
12615   struct dump_list_entry * cur;
12616
12617   for (cur = dump_sects_byname; cur; cur = cur->next)
12618     {
12619       unsigned int i;
12620       int any;
12621
12622       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12623         if (streq (SECTION_NAME (section_headers + i), cur->name))
12624           {
12625             request_dump_bynumber (i, cur->type);
12626             any = 1;
12627           }
12628
12629       if (!any)
12630         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12631               cur->name);
12632     }
12633 }
12634
12635 static void
12636 process_section_contents (FILE * file)
12637 {
12638   Elf_Internal_Shdr * section;
12639   unsigned int i;
12640
12641   if (! do_dump)
12642     return;
12643
12644   initialise_dumps_byname ();
12645
12646   for (i = 0, section = section_headers;
12647        i < elf_header.e_shnum && i < num_dump_sects;
12648        i++, section++)
12649     {
12650 #ifdef SUPPORT_DISASSEMBLY
12651       if (dump_sects[i] & DISASS_DUMP)
12652         disassemble_section (section, file);
12653 #endif
12654       if (dump_sects[i] & HEX_DUMP)
12655         dump_section_as_bytes (section, file, FALSE);
12656
12657       if (dump_sects[i] & RELOC_DUMP)
12658         dump_section_as_bytes (section, file, TRUE);
12659
12660       if (dump_sects[i] & STRING_DUMP)
12661         dump_section_as_strings (section, file);
12662
12663       if (dump_sects[i] & DEBUG_DUMP)
12664         display_debug_section (i, section, file);
12665     }
12666
12667   /* Check to see if the user requested a
12668      dump of a section that does not exist.  */
12669   while (i++ < num_dump_sects)
12670     if (dump_sects[i])
12671       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12672 }
12673
12674 static void
12675 process_mips_fpe_exception (int mask)
12676 {
12677   if (mask)
12678     {
12679       int first = 1;
12680       if (mask & OEX_FPU_INEX)
12681         fputs ("INEX", stdout), first = 0;
12682       if (mask & OEX_FPU_UFLO)
12683         printf ("%sUFLO", first ? "" : "|"), first = 0;
12684       if (mask & OEX_FPU_OFLO)
12685         printf ("%sOFLO", first ? "" : "|"), first = 0;
12686       if (mask & OEX_FPU_DIV0)
12687         printf ("%sDIV0", first ? "" : "|"), first = 0;
12688       if (mask & OEX_FPU_INVAL)
12689         printf ("%sINVAL", first ? "" : "|");
12690     }
12691   else
12692     fputs ("0", stdout);
12693 }
12694
12695 /* Display's the value of TAG at location P.  If TAG is
12696    greater than 0 it is assumed to be an unknown tag, and
12697    a message is printed to this effect.  Otherwise it is
12698    assumed that a message has already been printed.
12699
12700    If the bottom bit of TAG is set it assumed to have a
12701    string value, otherwise it is assumed to have an integer
12702    value.
12703
12704    Returns an updated P pointing to the first unread byte
12705    beyond the end of TAG's value.
12706
12707    Reads at or beyond END will not be made.  */
12708
12709 static unsigned char *
12710 display_tag_value (int tag,
12711                    unsigned char * p,
12712                    const unsigned char * const end)
12713 {
12714   unsigned long val;
12715
12716   if (tag > 0)
12717     printf ("  Tag_unknown_%d: ", tag);
12718
12719   if (p >= end)
12720     {
12721       warn (_("<corrupt tag>\n"));
12722     }
12723   else if (tag & 1)
12724     {
12725       /* PR 17531 file: 027-19978-0.004.  */
12726       size_t maxlen = (end - p) - 1;
12727
12728       putchar ('"');
12729       if (maxlen > 0)
12730         {
12731           print_symbol ((int) maxlen, (const char *) p);
12732           p += strnlen ((char *) p, maxlen) + 1;
12733         }
12734       else
12735         {
12736           printf (_("<corrupt string tag>"));
12737           p = (unsigned char *) end;
12738         }
12739       printf ("\"\n");
12740     }
12741   else
12742     {
12743       unsigned int len;
12744
12745       val = read_uleb128 (p, &len, end);
12746       p += len;
12747       printf ("%ld (0x%lx)\n", val, val);
12748     }
12749
12750   assert (p <= end);
12751   return p;
12752 }
12753
12754 /* ARM EABI attributes section.  */
12755 typedef struct
12756 {
12757   unsigned int tag;
12758   const char * name;
12759   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12760   unsigned int type;
12761   const char ** table;
12762 } arm_attr_public_tag;
12763
12764 static const char * arm_attr_tag_CPU_arch[] =
12765   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12766    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12767    "v8-M.mainline"};
12768 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12769 static const char * arm_attr_tag_THUMB_ISA_use[] =
12770   {"No", "Thumb-1", "Thumb-2", "Yes"};
12771 static const char * arm_attr_tag_FP_arch[] =
12772   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12773    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12774 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12775 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12776   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12777 static const char * arm_attr_tag_PCS_config[] =
12778   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12779    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12780 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12781   {"V6", "SB", "TLS", "Unused"};
12782 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12783   {"Absolute", "PC-relative", "SB-relative", "None"};
12784 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12785   {"Absolute", "PC-relative", "None"};
12786 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12787   {"None", "direct", "GOT-indirect"};
12788 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12789   {"None", "??? 1", "2", "??? 3", "4"};
12790 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12791 static const char * arm_attr_tag_ABI_FP_denormal[] =
12792   {"Unused", "Needed", "Sign only"};
12793 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12794 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12795 static const char * arm_attr_tag_ABI_FP_number_model[] =
12796   {"Unused", "Finite", "RTABI", "IEEE 754"};
12797 static const char * arm_attr_tag_ABI_enum_size[] =
12798   {"Unused", "small", "int", "forced to int"};
12799 static const char * arm_attr_tag_ABI_HardFP_use[] =
12800   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12801 static const char * arm_attr_tag_ABI_VFP_args[] =
12802   {"AAPCS", "VFP registers", "custom", "compatible"};
12803 static const char * arm_attr_tag_ABI_WMMX_args[] =
12804   {"AAPCS", "WMMX registers", "custom"};
12805 static const char * arm_attr_tag_ABI_optimization_goals[] =
12806   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12807     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12808 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12809   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12810     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12811 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12812 static const char * arm_attr_tag_FP_HP_extension[] =
12813   {"Not Allowed", "Allowed"};
12814 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12815   {"None", "IEEE 754", "Alternative Format"};
12816 static const char * arm_attr_tag_MPextension_use[] =
12817   {"Not Allowed", "Allowed"};
12818 static const char * arm_attr_tag_DIV_use[] =
12819   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12820     "Allowed in v7-A with integer division extension"};
12821 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12822 static const char * arm_attr_tag_Virtualization_use[] =
12823   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12824     "TrustZone and Virtualization Extensions"};
12825 static const char * arm_attr_tag_MPextension_use_legacy[] =
12826   {"Not Allowed", "Allowed"};
12827
12828 #define LOOKUP(id, name) \
12829   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12830 static arm_attr_public_tag arm_attr_public_tags[] =
12831 {
12832   {4, "CPU_raw_name", 1, NULL},
12833   {5, "CPU_name", 1, NULL},
12834   LOOKUP(6, CPU_arch),
12835   {7, "CPU_arch_profile", 0, NULL},
12836   LOOKUP(8, ARM_ISA_use),
12837   LOOKUP(9, THUMB_ISA_use),
12838   LOOKUP(10, FP_arch),
12839   LOOKUP(11, WMMX_arch),
12840   LOOKUP(12, Advanced_SIMD_arch),
12841   LOOKUP(13, PCS_config),
12842   LOOKUP(14, ABI_PCS_R9_use),
12843   LOOKUP(15, ABI_PCS_RW_data),
12844   LOOKUP(16, ABI_PCS_RO_data),
12845   LOOKUP(17, ABI_PCS_GOT_use),
12846   LOOKUP(18, ABI_PCS_wchar_t),
12847   LOOKUP(19, ABI_FP_rounding),
12848   LOOKUP(20, ABI_FP_denormal),
12849   LOOKUP(21, ABI_FP_exceptions),
12850   LOOKUP(22, ABI_FP_user_exceptions),
12851   LOOKUP(23, ABI_FP_number_model),
12852   {24, "ABI_align_needed", 0, NULL},
12853   {25, "ABI_align_preserved", 0, NULL},
12854   LOOKUP(26, ABI_enum_size),
12855   LOOKUP(27, ABI_HardFP_use),
12856   LOOKUP(28, ABI_VFP_args),
12857   LOOKUP(29, ABI_WMMX_args),
12858   LOOKUP(30, ABI_optimization_goals),
12859   LOOKUP(31, ABI_FP_optimization_goals),
12860   {32, "compatibility", 0, NULL},
12861   LOOKUP(34, CPU_unaligned_access),
12862   LOOKUP(36, FP_HP_extension),
12863   LOOKUP(38, ABI_FP_16bit_format),
12864   LOOKUP(42, MPextension_use),
12865   LOOKUP(44, DIV_use),
12866   {64, "nodefaults", 0, NULL},
12867   {65, "also_compatible_with", 0, NULL},
12868   LOOKUP(66, T2EE_use),
12869   {67, "conformance", 1, NULL},
12870   LOOKUP(68, Virtualization_use),
12871   LOOKUP(70, MPextension_use_legacy)
12872 };
12873 #undef LOOKUP
12874
12875 static unsigned char *
12876 display_arm_attribute (unsigned char * p,
12877                        const unsigned char * const end)
12878 {
12879   unsigned int tag;
12880   unsigned int len;
12881   unsigned int val;
12882   arm_attr_public_tag * attr;
12883   unsigned i;
12884   unsigned int type;
12885
12886   tag = read_uleb128 (p, &len, end);
12887   p += len;
12888   attr = NULL;
12889   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12890     {
12891       if (arm_attr_public_tags[i].tag == tag)
12892         {
12893           attr = &arm_attr_public_tags[i];
12894           break;
12895         }
12896     }
12897
12898   if (attr)
12899     {
12900       printf ("  Tag_%s: ", attr->name);
12901       switch (attr->type)
12902         {
12903         case 0:
12904           switch (tag)
12905             {
12906             case 7: /* Tag_CPU_arch_profile.  */
12907               val = read_uleb128 (p, &len, end);
12908               p += len;
12909               switch (val)
12910                 {
12911                 case 0: printf (_("None\n")); break;
12912                 case 'A': printf (_("Application\n")); break;
12913                 case 'R': printf (_("Realtime\n")); break;
12914                 case 'M': printf (_("Microcontroller\n")); break;
12915                 case 'S': printf (_("Application or Realtime\n")); break;
12916                 default: printf ("??? (%d)\n", val); break;
12917                 }
12918               break;
12919
12920             case 24: /* Tag_align_needed.  */
12921               val = read_uleb128 (p, &len, end);
12922               p += len;
12923               switch (val)
12924                 {
12925                 case 0: printf (_("None\n")); break;
12926                 case 1: printf (_("8-byte\n")); break;
12927                 case 2: printf (_("4-byte\n")); break;
12928                 case 3: printf ("??? 3\n"); break;
12929                 default:
12930                   if (val <= 12)
12931                     printf (_("8-byte and up to %d-byte extended\n"),
12932                             1 << val);
12933                   else
12934                     printf ("??? (%d)\n", val);
12935                   break;
12936                 }
12937               break;
12938
12939             case 25: /* Tag_align_preserved.  */
12940               val = read_uleb128 (p, &len, end);
12941               p += len;
12942               switch (val)
12943                 {
12944                 case 0: printf (_("None\n")); break;
12945                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12946                 case 2: printf (_("8-byte\n")); break;
12947                 case 3: printf ("??? 3\n"); break;
12948                 default:
12949                   if (val <= 12)
12950                     printf (_("8-byte and up to %d-byte extended\n"),
12951                             1 << val);
12952                   else
12953                     printf ("??? (%d)\n", val);
12954                   break;
12955                 }
12956               break;
12957
12958             case 32: /* Tag_compatibility.  */
12959               {
12960                 val = read_uleb128 (p, &len, end);
12961                 p += len;
12962                 printf (_("flag = %d, vendor = "), val);
12963                 if (p < end - 1)
12964                   {
12965                     size_t maxlen = (end - p) - 1;
12966
12967                     print_symbol ((int) maxlen, (const char *) p);
12968                     p += strnlen ((char *) p, maxlen) + 1;
12969                   }
12970                 else
12971                   {
12972                     printf (_("<corrupt>"));
12973                     p = (unsigned char *) end;
12974                   }
12975                 putchar ('\n');
12976               }
12977               break;
12978
12979             case 64: /* Tag_nodefaults.  */
12980               /* PR 17531: file: 001-505008-0.01.  */
12981               if (p < end)
12982                 p++;
12983               printf (_("True\n"));
12984               break;
12985
12986             case 65: /* Tag_also_compatible_with.  */
12987               val = read_uleb128 (p, &len, end);
12988               p += len;
12989               if (val == 6 /* Tag_CPU_arch.  */)
12990                 {
12991                   val = read_uleb128 (p, &len, end);
12992                   p += len;
12993                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12994                     printf ("??? (%d)\n", val);
12995                   else
12996                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12997                 }
12998               else
12999                 printf ("???\n");
13000               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13001                 ;
13002               break;
13003
13004             default:
13005               printf (_("<unknown: %d>\n"), tag);
13006               break;
13007             }
13008           return p;
13009
13010         case 1:
13011           return display_tag_value (-1, p, end);
13012         case 2:
13013           return display_tag_value (0, p, end);
13014
13015         default:
13016           assert (attr->type & 0x80);
13017           val = read_uleb128 (p, &len, end);
13018           p += len;
13019           type = attr->type & 0x7f;
13020           if (val >= type)
13021             printf ("??? (%d)\n", val);
13022           else
13023             printf ("%s\n", attr->table[val]);
13024           return p;
13025         }
13026     }
13027
13028   return display_tag_value (tag, p, end);
13029 }
13030
13031 static unsigned char *
13032 display_gnu_attribute (unsigned char * p,
13033                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13034                        const unsigned char * const end)
13035 {
13036   int tag;
13037   unsigned int len;
13038   int val;
13039
13040   tag = read_uleb128 (p, &len, end);
13041   p += len;
13042
13043   /* Tag_compatibility is the only generic GNU attribute defined at
13044      present.  */
13045   if (tag == 32)
13046     {
13047       val = read_uleb128 (p, &len, end);
13048       p += len;
13049
13050       printf (_("flag = %d, vendor = "), val);
13051       if (p == end)
13052         {
13053           printf (_("<corrupt>\n"));
13054           warn (_("corrupt vendor attribute\n"));
13055         }
13056       else
13057         {
13058           if (p < end - 1)
13059             {
13060               size_t maxlen = (end - p) - 1;
13061
13062               print_symbol ((int) maxlen, (const char *) p);
13063               p += strnlen ((char *) p, maxlen) + 1;
13064             }
13065           else
13066             {
13067               printf (_("<corrupt>"));
13068               p = (unsigned char *) end;
13069             }
13070           putchar ('\n');
13071         }
13072       return p;
13073     }
13074
13075   if ((tag & 2) == 0 && display_proc_gnu_attribute)
13076     return display_proc_gnu_attribute (p, tag, end);
13077
13078   return display_tag_value (tag, p, end);
13079 }
13080
13081 static unsigned char *
13082 display_power_gnu_attribute (unsigned char * p,
13083                              int tag,
13084                              const unsigned char * const end)
13085 {
13086   unsigned int len;
13087   int val;
13088
13089   if (tag == Tag_GNU_Power_ABI_FP)
13090     {
13091       val = read_uleb128 (p, &len, end);
13092       p += len;
13093       printf ("  Tag_GNU_Power_ABI_FP: ");
13094
13095       switch (val)
13096         {
13097         case 0:
13098           printf (_("Hard or soft float\n"));
13099           break;
13100         case 1:
13101           printf (_("Hard float\n"));
13102           break;
13103         case 2:
13104           printf (_("Soft float\n"));
13105           break;
13106         case 3:
13107           printf (_("Single-precision hard float\n"));
13108           break;
13109         default:
13110           printf ("??? (%d)\n", val);
13111           break;
13112         }
13113       return p;
13114    }
13115
13116   if (tag == Tag_GNU_Power_ABI_Vector)
13117     {
13118       val = read_uleb128 (p, &len, end);
13119       p += len;
13120       printf ("  Tag_GNU_Power_ABI_Vector: ");
13121       switch (val)
13122         {
13123         case 0:
13124           printf (_("Any\n"));
13125           break;
13126         case 1:
13127           printf (_("Generic\n"));
13128           break;
13129         case 2:
13130           printf ("AltiVec\n");
13131           break;
13132         case 3:
13133           printf ("SPE\n");
13134           break;
13135         default:
13136           printf ("??? (%d)\n", val);
13137           break;
13138         }
13139       return p;
13140    }
13141
13142   if (tag == Tag_GNU_Power_ABI_Struct_Return)
13143     {
13144       if (p == end)
13145         {
13146           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13147           return p;
13148         }
13149
13150       val = read_uleb128 (p, &len, end);
13151       p += len;
13152       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13153       switch (val)
13154        {
13155        case 0:
13156          printf (_("Any\n"));
13157          break;
13158        case 1:
13159          printf ("r3/r4\n");
13160          break;
13161        case 2:
13162          printf (_("Memory\n"));
13163          break;
13164        default:
13165          printf ("??? (%d)\n", val);
13166          break;
13167        }
13168       return p;
13169     }
13170
13171   return display_tag_value (tag & 1, p, end);
13172 }
13173
13174 static unsigned char *
13175 display_s390_gnu_attribute (unsigned char * p,
13176                             int tag,
13177                             const unsigned char * const end)
13178 {
13179   unsigned int len;
13180   int val;
13181
13182   if (tag == Tag_GNU_S390_ABI_Vector)
13183     {
13184       val = read_uleb128 (p, &len, end);
13185       p += len;
13186       printf ("  Tag_GNU_S390_ABI_Vector: ");
13187
13188       switch (val)
13189         {
13190         case 0:
13191           printf (_("any\n"));
13192           break;
13193         case 1:
13194           printf (_("software\n"));
13195           break;
13196         case 2:
13197           printf (_("hardware\n"));
13198           break;
13199         default:
13200           printf ("??? (%d)\n", val);
13201           break;
13202         }
13203       return p;
13204    }
13205
13206   return display_tag_value (tag & 1, p, end);
13207 }
13208
13209 static void
13210 display_sparc_hwcaps (int mask)
13211 {
13212   if (mask)
13213     {
13214       int first = 1;
13215
13216       if (mask & ELF_SPARC_HWCAP_MUL32)
13217         fputs ("mul32", stdout), first = 0;
13218       if (mask & ELF_SPARC_HWCAP_DIV32)
13219         printf ("%sdiv32", first ? "" : "|"), first = 0;
13220       if (mask & ELF_SPARC_HWCAP_FSMULD)
13221         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13222       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13223         printf ("%sv8plus", first ? "" : "|"), first = 0;
13224       if (mask & ELF_SPARC_HWCAP_POPC)
13225         printf ("%spopc", first ? "" : "|"), first = 0;
13226       if (mask & ELF_SPARC_HWCAP_VIS)
13227         printf ("%svis", first ? "" : "|"), first = 0;
13228       if (mask & ELF_SPARC_HWCAP_VIS2)
13229         printf ("%svis2", first ? "" : "|"), first = 0;
13230       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13231         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13232       if (mask & ELF_SPARC_HWCAP_FMAF)
13233         printf ("%sfmaf", first ? "" : "|"), first = 0;
13234       if (mask & ELF_SPARC_HWCAP_VIS3)
13235         printf ("%svis3", first ? "" : "|"), first = 0;
13236       if (mask & ELF_SPARC_HWCAP_HPC)
13237         printf ("%shpc", first ? "" : "|"), first = 0;
13238       if (mask & ELF_SPARC_HWCAP_RANDOM)
13239         printf ("%srandom", first ? "" : "|"), first = 0;
13240       if (mask & ELF_SPARC_HWCAP_TRANS)
13241         printf ("%strans", first ? "" : "|"), first = 0;
13242       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13243         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13244       if (mask & ELF_SPARC_HWCAP_IMA)
13245         printf ("%sima", first ? "" : "|"), first = 0;
13246       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13247         printf ("%scspare", first ? "" : "|"), first = 0;
13248     }
13249   else
13250     fputc ('0', stdout);
13251   fputc ('\n', stdout);
13252 }
13253
13254 static void
13255 display_sparc_hwcaps2 (int mask)
13256 {
13257   if (mask)
13258     {
13259       int first = 1;
13260
13261       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13262         fputs ("fjathplus", stdout), first = 0;
13263       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13264         printf ("%svis3b", first ? "" : "|"), first = 0;
13265       if (mask & ELF_SPARC_HWCAP2_ADP)
13266         printf ("%sadp", first ? "" : "|"), first = 0;
13267       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13268         printf ("%ssparc5", first ? "" : "|"), first = 0;
13269       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13270         printf ("%smwait", first ? "" : "|"), first = 0;
13271       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13272         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13273       if (mask & ELF_SPARC_HWCAP2_XMONT)
13274         printf ("%sxmont2", first ? "" : "|"), first = 0;
13275       if (mask & ELF_SPARC_HWCAP2_NSEC)
13276         printf ("%snsec", first ? "" : "|"), first = 0;
13277       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13278         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13279       if (mask & ELF_SPARC_HWCAP2_FJDES)
13280         printf ("%sfjdes", first ? "" : "|"), first = 0;
13281       if (mask & ELF_SPARC_HWCAP2_FJAES)
13282         printf ("%sfjaes", first ? "" : "|"), first = 0;
13283     }
13284   else
13285     fputc ('0', stdout);
13286   fputc ('\n', stdout);
13287 }
13288
13289 static unsigned char *
13290 display_sparc_gnu_attribute (unsigned char * p,
13291                              int tag,
13292                              const unsigned char * const end)
13293 {
13294   unsigned int len;
13295   int val;
13296
13297   if (tag == Tag_GNU_Sparc_HWCAPS)
13298     {
13299       val = read_uleb128 (p, &len, end);
13300       p += len;
13301       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13302       display_sparc_hwcaps (val);
13303       return p;
13304     }
13305   if (tag == Tag_GNU_Sparc_HWCAPS2)
13306     {
13307       val = read_uleb128 (p, &len, end);
13308       p += len;
13309       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13310       display_sparc_hwcaps2 (val);
13311       return p;
13312     }
13313
13314   return display_tag_value (tag, p, end);
13315 }
13316
13317 static void
13318 print_mips_fp_abi_value (int val)
13319 {
13320   switch (val)
13321     {
13322     case Val_GNU_MIPS_ABI_FP_ANY:
13323       printf (_("Hard or soft float\n"));
13324       break;
13325     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13326       printf (_("Hard float (double precision)\n"));
13327       break;
13328     case Val_GNU_MIPS_ABI_FP_SINGLE:
13329       printf (_("Hard float (single precision)\n"));
13330       break;
13331     case Val_GNU_MIPS_ABI_FP_SOFT:
13332       printf (_("Soft float\n"));
13333       break;
13334     case Val_GNU_MIPS_ABI_FP_OLD_64:
13335       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13336       break;
13337     case Val_GNU_MIPS_ABI_FP_XX:
13338       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13339       break;
13340     case Val_GNU_MIPS_ABI_FP_64:
13341       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13342       break;
13343     case Val_GNU_MIPS_ABI_FP_64A:
13344       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13345       break;
13346     case Val_GNU_MIPS_ABI_FP_NAN2008:
13347       printf (_("NaN 2008 compatibility\n"));
13348       break;
13349     default:
13350       printf ("??? (%d)\n", val);
13351       break;
13352     }
13353 }
13354
13355 static unsigned char *
13356 display_mips_gnu_attribute (unsigned char * p,
13357                             int tag,
13358                             const unsigned char * const end)
13359 {
13360   if (tag == Tag_GNU_MIPS_ABI_FP)
13361     {
13362       unsigned int len;
13363       int val;
13364
13365       val = read_uleb128 (p, &len, end);
13366       p += len;
13367       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13368
13369       print_mips_fp_abi_value (val);
13370
13371       return p;
13372    }
13373
13374   if (tag == Tag_GNU_MIPS_ABI_MSA)
13375     {
13376       unsigned int len;
13377       int val;
13378
13379       val = read_uleb128 (p, &len, end);
13380       p += len;
13381       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13382
13383       switch (val)
13384         {
13385         case Val_GNU_MIPS_ABI_MSA_ANY:
13386           printf (_("Any MSA or not\n"));
13387           break;
13388         case Val_GNU_MIPS_ABI_MSA_128:
13389           printf (_("128-bit MSA\n"));
13390           break;
13391         default:
13392           printf ("??? (%d)\n", val);
13393           break;
13394         }
13395       return p;
13396     }
13397
13398   return display_tag_value (tag & 1, p, end);
13399 }
13400
13401 static unsigned char *
13402 display_tic6x_attribute (unsigned char * p,
13403                          const unsigned char * const end)
13404 {
13405   int tag;
13406   unsigned int len;
13407   int val;
13408
13409   tag = read_uleb128 (p, &len, end);
13410   p += len;
13411
13412   switch (tag)
13413     {
13414     case Tag_ISA:
13415       val = read_uleb128 (p, &len, end);
13416       p += len;
13417       printf ("  Tag_ISA: ");
13418
13419       switch (val)
13420         {
13421         case C6XABI_Tag_ISA_none:
13422           printf (_("None\n"));
13423           break;
13424         case C6XABI_Tag_ISA_C62X:
13425           printf ("C62x\n");
13426           break;
13427         case C6XABI_Tag_ISA_C67X:
13428           printf ("C67x\n");
13429           break;
13430         case C6XABI_Tag_ISA_C67XP:
13431           printf ("C67x+\n");
13432           break;
13433         case C6XABI_Tag_ISA_C64X:
13434           printf ("C64x\n");
13435           break;
13436         case C6XABI_Tag_ISA_C64XP:
13437           printf ("C64x+\n");
13438           break;
13439         case C6XABI_Tag_ISA_C674X:
13440           printf ("C674x\n");
13441           break;
13442         default:
13443           printf ("??? (%d)\n", val);
13444           break;
13445         }
13446       return p;
13447
13448     case Tag_ABI_wchar_t:
13449       val = read_uleb128 (p, &len, end);
13450       p += len;
13451       printf ("  Tag_ABI_wchar_t: ");
13452       switch (val)
13453         {
13454         case 0:
13455           printf (_("Not used\n"));
13456           break;
13457         case 1:
13458           printf (_("2 bytes\n"));
13459           break;
13460         case 2:
13461           printf (_("4 bytes\n"));
13462           break;
13463         default:
13464           printf ("??? (%d)\n", val);
13465           break;
13466         }
13467       return p;
13468
13469     case Tag_ABI_stack_align_needed:
13470       val = read_uleb128 (p, &len, end);
13471       p += len;
13472       printf ("  Tag_ABI_stack_align_needed: ");
13473       switch (val)
13474         {
13475         case 0:
13476           printf (_("8-byte\n"));
13477           break;
13478         case 1:
13479           printf (_("16-byte\n"));
13480           break;
13481         default:
13482           printf ("??? (%d)\n", val);
13483           break;
13484         }
13485       return p;
13486
13487     case Tag_ABI_stack_align_preserved:
13488       val = read_uleb128 (p, &len, end);
13489       p += len;
13490       printf ("  Tag_ABI_stack_align_preserved: ");
13491       switch (val)
13492         {
13493         case 0:
13494           printf (_("8-byte\n"));
13495           break;
13496         case 1:
13497           printf (_("16-byte\n"));
13498           break;
13499         default:
13500           printf ("??? (%d)\n", val);
13501           break;
13502         }
13503       return p;
13504
13505     case Tag_ABI_DSBT:
13506       val = read_uleb128 (p, &len, end);
13507       p += len;
13508       printf ("  Tag_ABI_DSBT: ");
13509       switch (val)
13510         {
13511         case 0:
13512           printf (_("DSBT addressing not used\n"));
13513           break;
13514         case 1:
13515           printf (_("DSBT addressing used\n"));
13516           break;
13517         default:
13518           printf ("??? (%d)\n", val);
13519           break;
13520         }
13521       return p;
13522
13523     case Tag_ABI_PID:
13524       val = read_uleb128 (p, &len, end);
13525       p += len;
13526       printf ("  Tag_ABI_PID: ");
13527       switch (val)
13528         {
13529         case 0:
13530           printf (_("Data addressing position-dependent\n"));
13531           break;
13532         case 1:
13533           printf (_("Data addressing position-independent, GOT near DP\n"));
13534           break;
13535         case 2:
13536           printf (_("Data addressing position-independent, GOT far from DP\n"));
13537           break;
13538         default:
13539           printf ("??? (%d)\n", val);
13540           break;
13541         }
13542       return p;
13543
13544     case Tag_ABI_PIC:
13545       val = read_uleb128 (p, &len, end);
13546       p += len;
13547       printf ("  Tag_ABI_PIC: ");
13548       switch (val)
13549         {
13550         case 0:
13551           printf (_("Code addressing position-dependent\n"));
13552           break;
13553         case 1:
13554           printf (_("Code addressing position-independent\n"));
13555           break;
13556         default:
13557           printf ("??? (%d)\n", val);
13558           break;
13559         }
13560       return p;
13561
13562     case Tag_ABI_array_object_alignment:
13563       val = read_uleb128 (p, &len, end);
13564       p += len;
13565       printf ("  Tag_ABI_array_object_alignment: ");
13566       switch (val)
13567         {
13568         case 0:
13569           printf (_("8-byte\n"));
13570           break;
13571         case 1:
13572           printf (_("4-byte\n"));
13573           break;
13574         case 2:
13575           printf (_("16-byte\n"));
13576           break;
13577         default:
13578           printf ("??? (%d)\n", val);
13579           break;
13580         }
13581       return p;
13582
13583     case Tag_ABI_array_object_align_expected:
13584       val = read_uleb128 (p, &len, end);
13585       p += len;
13586       printf ("  Tag_ABI_array_object_align_expected: ");
13587       switch (val)
13588         {
13589         case 0:
13590           printf (_("8-byte\n"));
13591           break;
13592         case 1:
13593           printf (_("4-byte\n"));
13594           break;
13595         case 2:
13596           printf (_("16-byte\n"));
13597           break;
13598         default:
13599           printf ("??? (%d)\n", val);
13600           break;
13601         }
13602       return p;
13603
13604     case Tag_ABI_compatibility:
13605       {
13606         val = read_uleb128 (p, &len, end);
13607         p += len;
13608         printf ("  Tag_ABI_compatibility: ");
13609         printf (_("flag = %d, vendor = "), val);
13610         if (p < end - 1)
13611           {
13612             size_t maxlen = (end - p) - 1;
13613
13614             print_symbol ((int) maxlen, (const char *) p);
13615             p += strnlen ((char *) p, maxlen) + 1;
13616           }
13617         else
13618           {
13619             printf (_("<corrupt>"));
13620             p = (unsigned char *) end;
13621           }
13622         putchar ('\n');
13623         return p;
13624       }
13625
13626     case Tag_ABI_conformance:
13627       {
13628         printf ("  Tag_ABI_conformance: \"");
13629         if (p < end - 1)
13630           {
13631             size_t maxlen = (end - p) - 1;
13632
13633             print_symbol ((int) maxlen, (const char *) p);
13634             p += strnlen ((char *) p, maxlen) + 1;
13635           }
13636         else
13637           {
13638             printf (_("<corrupt>"));
13639             p = (unsigned char *) end;
13640           }
13641         printf ("\"\n");
13642         return p;
13643       }
13644     }
13645
13646   return display_tag_value (tag, p, end);
13647 }
13648
13649 static void
13650 display_raw_attribute (unsigned char * p, unsigned char * end)
13651 {
13652   unsigned long addr = 0;
13653   size_t bytes = end - p;
13654
13655   assert (end > p);
13656   while (bytes)
13657     {
13658       int j;
13659       int k;
13660       int lbytes = (bytes > 16 ? 16 : bytes);
13661
13662       printf ("  0x%8.8lx ", addr);
13663
13664       for (j = 0; j < 16; j++)
13665         {
13666           if (j < lbytes)
13667             printf ("%2.2x", p[j]);
13668           else
13669             printf ("  ");
13670
13671           if ((j & 3) == 3)
13672             printf (" ");
13673         }
13674
13675       for (j = 0; j < lbytes; j++)
13676         {
13677           k = p[j];
13678           if (k >= ' ' && k < 0x7f)
13679             printf ("%c", k);
13680           else
13681             printf (".");
13682         }
13683
13684       putchar ('\n');
13685
13686       p  += lbytes;
13687       bytes -= lbytes;
13688       addr += lbytes;
13689     }
13690
13691   putchar ('\n');
13692 }
13693
13694 static unsigned char *
13695 display_msp430x_attribute (unsigned char * p,
13696                            const unsigned char * const end)
13697 {
13698   unsigned int len;
13699   int val;
13700   int tag;
13701
13702   tag = read_uleb128 (p, & len, end);
13703   p += len;
13704
13705   switch (tag)
13706     {
13707     case OFBA_MSPABI_Tag_ISA:
13708       val = read_uleb128 (p, &len, end);
13709       p += len;
13710       printf ("  Tag_ISA: ");
13711       switch (val)
13712         {
13713         case 0: printf (_("None\n")); break;
13714         case 1: printf (_("MSP430\n")); break;
13715         case 2: printf (_("MSP430X\n")); break;
13716         default: printf ("??? (%d)\n", val); break;
13717         }
13718       break;
13719
13720     case OFBA_MSPABI_Tag_Code_Model:
13721       val = read_uleb128 (p, &len, end);
13722       p += len;
13723       printf ("  Tag_Code_Model: ");
13724       switch (val)
13725         {
13726         case 0: printf (_("None\n")); break;
13727         case 1: printf (_("Small\n")); break;
13728         case 2: printf (_("Large\n")); break;
13729         default: printf ("??? (%d)\n", val); break;
13730         }
13731       break;
13732
13733     case OFBA_MSPABI_Tag_Data_Model:
13734       val = read_uleb128 (p, &len, end);
13735       p += len;
13736       printf ("  Tag_Data_Model: ");
13737       switch (val)
13738         {
13739         case 0: printf (_("None\n")); break;
13740         case 1: printf (_("Small\n")); break;
13741         case 2: printf (_("Large\n")); break;
13742         case 3: printf (_("Restricted Large\n")); break;
13743         default: printf ("??? (%d)\n", val); break;
13744         }
13745       break;
13746
13747     default:
13748       printf (_("  <unknown tag %d>: "), tag);
13749
13750       if (tag & 1)
13751         {
13752           putchar ('"');
13753           if (p < end - 1)
13754             {
13755               size_t maxlen = (end - p) - 1;
13756
13757               print_symbol ((int) maxlen, (const char *) p);
13758               p += strnlen ((char *) p, maxlen) + 1;
13759             }
13760           else
13761             {
13762               printf (_("<corrupt>"));
13763               p = (unsigned char *) end;
13764             }
13765           printf ("\"\n");
13766         }
13767       else
13768         {
13769           val = read_uleb128 (p, &len, end);
13770           p += len;
13771           printf ("%d (0x%x)\n", val, val);
13772         }
13773       break;
13774    }
13775
13776   assert (p <= end);
13777   return p;
13778 }
13779
13780 static int
13781 process_attributes (FILE * file,
13782                     const char * public_name,
13783                     unsigned int proc_type,
13784                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13785                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13786 {
13787   Elf_Internal_Shdr * sect;
13788   unsigned i;
13789
13790   /* Find the section header so that we get the size.  */
13791   for (i = 0, sect = section_headers;
13792        i < elf_header.e_shnum;
13793        i++, sect++)
13794     {
13795       unsigned char * contents;
13796       unsigned char * p;
13797
13798       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13799         continue;
13800
13801       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13802                                              sect->sh_size, _("attributes"));
13803       if (contents == NULL)
13804         continue;
13805
13806       p = contents;
13807       if (*p == 'A')
13808         {
13809           bfd_vma section_len;
13810
13811           section_len = sect->sh_size - 1;
13812           p++;
13813
13814           while (section_len > 0)
13815             {
13816               bfd_vma attr_len;
13817               unsigned int namelen;
13818               bfd_boolean public_section;
13819               bfd_boolean gnu_section;
13820
13821               if (section_len <= 4)
13822                 {
13823                   error (_("Tag section ends prematurely\n"));
13824                   break;
13825                 }
13826               attr_len = byte_get (p, 4);
13827               p += 4;
13828
13829               if (attr_len > section_len)
13830                 {
13831                   error (_("Bad attribute length (%u > %u)\n"),
13832                           (unsigned) attr_len, (unsigned) section_len);
13833                   attr_len = section_len;
13834                 }
13835               /* PR 17531: file: 001-101425-0.004  */
13836               else if (attr_len < 5)
13837                 {
13838                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13839                   break;
13840                 }
13841
13842               section_len -= attr_len;
13843               attr_len -= 4;
13844
13845               namelen = strnlen ((char *) p, attr_len) + 1;
13846               if (namelen == 0 || namelen >= attr_len)
13847                 {
13848                   error (_("Corrupt attribute section name\n"));
13849                   break;
13850                 }
13851
13852               printf (_("Attribute Section: "));
13853               print_symbol (INT_MAX, (const char *) p);
13854               putchar ('\n');
13855
13856               if (public_name && streq ((char *) p, public_name))
13857                 public_section = TRUE;
13858               else
13859                 public_section = FALSE;
13860
13861               if (streq ((char *) p, "gnu"))
13862                 gnu_section = TRUE;
13863               else
13864                 gnu_section = FALSE;
13865
13866               p += namelen;
13867               attr_len -= namelen;
13868
13869               while (attr_len > 0 && p < contents + sect->sh_size)
13870                 {
13871                   int tag;
13872                   int val;
13873                   bfd_vma size;
13874                   unsigned char * end;
13875
13876                   /* PR binutils/17531: Safe handling of corrupt files.  */
13877                   if (attr_len < 6)
13878                     {
13879                       error (_("Unused bytes at end of section\n"));
13880                       section_len = 0;
13881                       break;
13882                     }
13883
13884                   tag = *(p++);
13885                   size = byte_get (p, 4);
13886                   if (size > attr_len)
13887                     {
13888                       error (_("Bad subsection length (%u > %u)\n"),
13889                               (unsigned) size, (unsigned) attr_len);
13890                       size = attr_len;
13891                     }
13892                   /* PR binutils/17531: Safe handling of corrupt files.  */
13893                   if (size < 6)
13894                     {
13895                       error (_("Bad subsection length (%u < 6)\n"),
13896                               (unsigned) size);
13897                       section_len = 0;
13898                       break;
13899                     }
13900
13901                   attr_len -= size;
13902                   end = p + size - 1;
13903                   assert (end <= contents + sect->sh_size);
13904                   p += 4;
13905
13906                   switch (tag)
13907                     {
13908                     case 1:
13909                       printf (_("File Attributes\n"));
13910                       break;
13911                     case 2:
13912                       printf (_("Section Attributes:"));
13913                       goto do_numlist;
13914                     case 3:
13915                       printf (_("Symbol Attributes:"));
13916                     do_numlist:
13917                       for (;;)
13918                         {
13919                           unsigned int j;
13920
13921                           val = read_uleb128 (p, &j, end);
13922                           p += j;
13923                           if (val == 0)
13924                             break;
13925                           printf (" %d", val);
13926                         }
13927                       printf ("\n");
13928                       break;
13929                     default:
13930                       printf (_("Unknown tag: %d\n"), tag);
13931                       public_section = FALSE;
13932                       break;
13933                     }
13934
13935                   if (public_section && display_pub_attribute != NULL)
13936                     {
13937                       while (p < end)
13938                         p = display_pub_attribute (p, end);
13939                       assert (p <= end);
13940                     }
13941                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13942                     {
13943                       while (p < end)
13944                         p = display_gnu_attribute (p,
13945                                                    display_proc_gnu_attribute,
13946                                                    end);
13947                       assert (p <= end);
13948                     }
13949                   else if (p < end)
13950                     {
13951                       printf (_("  Unknown attribute:\n"));
13952                       display_raw_attribute (p, end);
13953                       p = end;
13954                     }
13955                   else
13956                     attr_len = 0;
13957                 }
13958             }
13959         }
13960       else
13961         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13962
13963       free (contents);
13964     }
13965   return 1;
13966 }
13967
13968 static int
13969 process_arm_specific (FILE * file)
13970 {
13971   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13972                              display_arm_attribute, NULL);
13973 }
13974
13975 static int
13976 process_power_specific (FILE * file)
13977 {
13978   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13979                              display_power_gnu_attribute);
13980 }
13981
13982 static int
13983 process_s390_specific (FILE * file)
13984 {
13985   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13986                              display_s390_gnu_attribute);
13987 }
13988
13989 static int
13990 process_sparc_specific (FILE * file)
13991 {
13992   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13993                              display_sparc_gnu_attribute);
13994 }
13995
13996 static int
13997 process_tic6x_specific (FILE * file)
13998 {
13999   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14000                              display_tic6x_attribute, NULL);
14001 }
14002
14003 static int
14004 process_msp430x_specific (FILE * file)
14005 {
14006   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14007                              display_msp430x_attribute, NULL);
14008 }
14009
14010 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14011    Print the Address, Access and Initial fields of an entry at VMA ADDR
14012    and return the VMA of the next entry, or -1 if there was a problem.
14013    Does not read from DATA_END or beyond.  */
14014
14015 static bfd_vma
14016 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14017                       unsigned char * data_end)
14018 {
14019   printf ("  ");
14020   print_vma (addr, LONG_HEX);
14021   printf (" ");
14022   if (addr < pltgot + 0xfff0)
14023     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14024   else
14025     printf ("%10s", "");
14026   printf (" ");
14027   if (data == NULL)
14028     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14029   else
14030     {
14031       bfd_vma entry;
14032       unsigned char * from = data + addr - pltgot;
14033
14034       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14035         {
14036           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14037           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14038           return (bfd_vma) -1;
14039         }
14040       else
14041         {
14042           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14043           print_vma (entry, LONG_HEX);
14044         }
14045     }
14046   return addr + (is_32bit_elf ? 4 : 8);
14047 }
14048
14049 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14050    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14051    ADDR and return the VMA of the next entry.  */
14052
14053 static bfd_vma
14054 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14055 {
14056   printf ("  ");
14057   print_vma (addr, LONG_HEX);
14058   printf (" ");
14059   if (data == NULL)
14060     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14061   else
14062     {
14063       bfd_vma entry;
14064
14065       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14066       print_vma (entry, LONG_HEX);
14067     }
14068   return addr + (is_32bit_elf ? 4 : 8);
14069 }
14070
14071 static void
14072 print_mips_ases (unsigned int mask)
14073 {
14074   if (mask & AFL_ASE_DSP)
14075     fputs ("\n\tDSP ASE", stdout);
14076   if (mask & AFL_ASE_DSPR2)
14077     fputs ("\n\tDSP R2 ASE", stdout);
14078   if (mask & AFL_ASE_EVA)
14079     fputs ("\n\tEnhanced VA Scheme", stdout);
14080   if (mask & AFL_ASE_MCU)
14081     fputs ("\n\tMCU (MicroController) ASE", stdout);
14082   if (mask & AFL_ASE_MDMX)
14083     fputs ("\n\tMDMX ASE", stdout);
14084   if (mask & AFL_ASE_MIPS3D)
14085     fputs ("\n\tMIPS-3D ASE", stdout);
14086   if (mask & AFL_ASE_MT)
14087     fputs ("\n\tMT ASE", stdout);
14088   if (mask & AFL_ASE_SMARTMIPS)
14089     fputs ("\n\tSmartMIPS ASE", stdout);
14090   if (mask & AFL_ASE_VIRT)
14091     fputs ("\n\tVZ ASE", stdout);
14092   if (mask & AFL_ASE_MSA)
14093     fputs ("\n\tMSA ASE", stdout);
14094   if (mask & AFL_ASE_MIPS16)
14095     fputs ("\n\tMIPS16 ASE", stdout);
14096   if (mask & AFL_ASE_MICROMIPS)
14097     fputs ("\n\tMICROMIPS ASE", stdout);
14098   if (mask & AFL_ASE_XPA)
14099     fputs ("\n\tXPA ASE", stdout);
14100   if (mask == 0)
14101     fprintf (stdout, "\n\t%s", _("None"));
14102   else if ((mask & ~AFL_ASE_MASK) != 0)
14103     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14104 }
14105
14106 static void
14107 print_mips_isa_ext (unsigned int isa_ext)
14108 {
14109   switch (isa_ext)
14110     {
14111     case 0:
14112       fputs (_("None"), stdout);
14113       break;
14114     case AFL_EXT_XLR:
14115       fputs ("RMI XLR", stdout);
14116       break;
14117     case AFL_EXT_OCTEON3:
14118       fputs ("Cavium Networks Octeon3", stdout);
14119       break;
14120     case AFL_EXT_OCTEON2:
14121       fputs ("Cavium Networks Octeon2", stdout);
14122       break;
14123     case AFL_EXT_OCTEONP:
14124       fputs ("Cavium Networks OcteonP", stdout);
14125       break;
14126     case AFL_EXT_LOONGSON_3A:
14127       fputs ("Loongson 3A", stdout);
14128       break;
14129     case AFL_EXT_OCTEON:
14130       fputs ("Cavium Networks Octeon", stdout);
14131       break;
14132     case AFL_EXT_5900:
14133       fputs ("Toshiba R5900", stdout);
14134       break;
14135     case AFL_EXT_4650:
14136       fputs ("MIPS R4650", stdout);
14137       break;
14138     case AFL_EXT_4010:
14139       fputs ("LSI R4010", stdout);
14140       break;
14141     case AFL_EXT_4100:
14142       fputs ("NEC VR4100", stdout);
14143       break;
14144     case AFL_EXT_3900:
14145       fputs ("Toshiba R3900", stdout);
14146       break;
14147     case AFL_EXT_10000:
14148       fputs ("MIPS R10000", stdout);
14149       break;
14150     case AFL_EXT_SB1:
14151       fputs ("Broadcom SB-1", stdout);
14152       break;
14153     case AFL_EXT_4111:
14154       fputs ("NEC VR4111/VR4181", stdout);
14155       break;
14156     case AFL_EXT_4120:
14157       fputs ("NEC VR4120", stdout);
14158       break;
14159     case AFL_EXT_5400:
14160       fputs ("NEC VR5400", stdout);
14161       break;
14162     case AFL_EXT_5500:
14163       fputs ("NEC VR5500", stdout);
14164       break;
14165     case AFL_EXT_LOONGSON_2E:
14166       fputs ("ST Microelectronics Loongson 2E", stdout);
14167       break;
14168     case AFL_EXT_LOONGSON_2F:
14169       fputs ("ST Microelectronics Loongson 2F", stdout);
14170       break;
14171     default:
14172       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14173     }
14174 }
14175
14176 static int
14177 get_mips_reg_size (int reg_size)
14178 {
14179   return (reg_size == AFL_REG_NONE) ? 0
14180          : (reg_size == AFL_REG_32) ? 32
14181          : (reg_size == AFL_REG_64) ? 64
14182          : (reg_size == AFL_REG_128) ? 128
14183          : -1;
14184 }
14185
14186 static int
14187 process_mips_specific (FILE * file)
14188 {
14189   Elf_Internal_Dyn * entry;
14190   Elf_Internal_Shdr *sect = NULL;
14191   size_t liblist_offset = 0;
14192   size_t liblistno = 0;
14193   size_t conflictsno = 0;
14194   size_t options_offset = 0;
14195   size_t conflicts_offset = 0;
14196   size_t pltrelsz = 0;
14197   size_t pltrel = 0;
14198   bfd_vma pltgot = 0;
14199   bfd_vma mips_pltgot = 0;
14200   bfd_vma jmprel = 0;
14201   bfd_vma local_gotno = 0;
14202   bfd_vma gotsym = 0;
14203   bfd_vma symtabno = 0;
14204
14205   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14206                       display_mips_gnu_attribute);
14207
14208   sect = find_section (".MIPS.abiflags");
14209
14210   if (sect != NULL)
14211     {
14212       Elf_External_ABIFlags_v0 *abiflags_ext;
14213       Elf_Internal_ABIFlags_v0 abiflags_in;
14214
14215       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14216         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14217       else
14218         {
14219           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14220                                    sect->sh_size, _("MIPS ABI Flags section"));
14221           if (abiflags_ext)
14222             {
14223               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14224               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14225               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14226               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14227               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14228               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14229               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14230               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14231               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14232               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14233               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14234
14235               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14236               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14237               if (abiflags_in.isa_rev > 1)
14238                 printf ("r%d", abiflags_in.isa_rev);
14239               printf ("\nGPR size: %d",
14240                       get_mips_reg_size (abiflags_in.gpr_size));
14241               printf ("\nCPR1 size: %d",
14242                       get_mips_reg_size (abiflags_in.cpr1_size));
14243               printf ("\nCPR2 size: %d",
14244                       get_mips_reg_size (abiflags_in.cpr2_size));
14245               fputs ("\nFP ABI: ", stdout);
14246               print_mips_fp_abi_value (abiflags_in.fp_abi);
14247               fputs ("ISA Extension: ", stdout);
14248               print_mips_isa_ext (abiflags_in.isa_ext);
14249               fputs ("\nASEs:", stdout);
14250               print_mips_ases (abiflags_in.ases);
14251               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14252               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14253               fputc ('\n', stdout);
14254               free (abiflags_ext);
14255             }
14256         }
14257     }
14258
14259   /* We have a lot of special sections.  Thanks SGI!  */
14260   if (dynamic_section == NULL)
14261     /* No information available.  */
14262     return 0;
14263
14264   for (entry = dynamic_section;
14265        /* PR 17531 file: 012-50589-0.004.  */
14266        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14267        ++entry)
14268     switch (entry->d_tag)
14269       {
14270       case DT_MIPS_LIBLIST:
14271         liblist_offset
14272           = offset_from_vma (file, entry->d_un.d_val,
14273                              liblistno * sizeof (Elf32_External_Lib));
14274         break;
14275       case DT_MIPS_LIBLISTNO:
14276         liblistno = entry->d_un.d_val;
14277         break;
14278       case DT_MIPS_OPTIONS:
14279         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14280         break;
14281       case DT_MIPS_CONFLICT:
14282         conflicts_offset
14283           = offset_from_vma (file, entry->d_un.d_val,
14284                              conflictsno * sizeof (Elf32_External_Conflict));
14285         break;
14286       case DT_MIPS_CONFLICTNO:
14287         conflictsno = entry->d_un.d_val;
14288         break;
14289       case DT_PLTGOT:
14290         pltgot = entry->d_un.d_ptr;
14291         break;
14292       case DT_MIPS_LOCAL_GOTNO:
14293         local_gotno = entry->d_un.d_val;
14294         break;
14295       case DT_MIPS_GOTSYM:
14296         gotsym = entry->d_un.d_val;
14297         break;
14298       case DT_MIPS_SYMTABNO:
14299         symtabno = entry->d_un.d_val;
14300         break;
14301       case DT_MIPS_PLTGOT:
14302         mips_pltgot = entry->d_un.d_ptr;
14303         break;
14304       case DT_PLTREL:
14305         pltrel = entry->d_un.d_val;
14306         break;
14307       case DT_PLTRELSZ:
14308         pltrelsz = entry->d_un.d_val;
14309         break;
14310       case DT_JMPREL:
14311         jmprel = entry->d_un.d_ptr;
14312         break;
14313       default:
14314         break;
14315       }
14316
14317   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14318     {
14319       Elf32_External_Lib * elib;
14320       size_t cnt;
14321
14322       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14323                                               liblistno,
14324                                               sizeof (Elf32_External_Lib),
14325                                               _("liblist section data"));
14326       if (elib)
14327         {
14328           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14329                   (unsigned long) liblistno);
14330           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14331                  stdout);
14332
14333           for (cnt = 0; cnt < liblistno; ++cnt)
14334             {
14335               Elf32_Lib liblist;
14336               time_t atime;
14337               char timebuf[20];
14338               struct tm * tmp;
14339
14340               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14341               atime = BYTE_GET (elib[cnt].l_time_stamp);
14342               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14343               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14344               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14345
14346               tmp = gmtime (&atime);
14347               snprintf (timebuf, sizeof (timebuf),
14348                         "%04u-%02u-%02uT%02u:%02u:%02u",
14349                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14350                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14351
14352               printf ("%3lu: ", (unsigned long) cnt);
14353               if (VALID_DYNAMIC_NAME (liblist.l_name))
14354                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14355               else
14356                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14357               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14358                       liblist.l_version);
14359
14360               if (liblist.l_flags == 0)
14361                 puts (_(" NONE"));
14362               else
14363                 {
14364                   static const struct
14365                   {
14366                     const char * name;
14367                     int bit;
14368                   }
14369                   l_flags_vals[] =
14370                   {
14371                     { " EXACT_MATCH", LL_EXACT_MATCH },
14372                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14373                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14374                     { " EXPORTS", LL_EXPORTS },
14375                     { " DELAY_LOAD", LL_DELAY_LOAD },
14376                     { " DELTA", LL_DELTA }
14377                   };
14378                   int flags = liblist.l_flags;
14379                   size_t fcnt;
14380
14381                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14382                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14383                       {
14384                         fputs (l_flags_vals[fcnt].name, stdout);
14385                         flags ^= l_flags_vals[fcnt].bit;
14386                       }
14387                   if (flags != 0)
14388                     printf (" %#x", (unsigned int) flags);
14389
14390                   puts ("");
14391                 }
14392             }
14393
14394           free (elib);
14395         }
14396     }
14397
14398   if (options_offset != 0)
14399     {
14400       Elf_External_Options * eopt;
14401       Elf_Internal_Options * iopt;
14402       Elf_Internal_Options * option;
14403       size_t offset;
14404       int cnt;
14405       sect = section_headers;
14406
14407       /* Find the section header so that we get the size.  */
14408       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14409       /* PR 17533 file: 012-277276-0.004.  */
14410       if (sect == NULL)
14411         {
14412           error (_("No MIPS_OPTIONS header found\n"));
14413           return 0;
14414         }
14415
14416       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14417                                                 sect->sh_size, _("options"));
14418       if (eopt)
14419         {
14420           iopt = (Elf_Internal_Options *)
14421               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14422           if (iopt == NULL)
14423             {
14424               error (_("Out of memory allocatinf space for MIPS options\n"));
14425               return 0;
14426             }
14427
14428           offset = cnt = 0;
14429           option = iopt;
14430
14431           while (offset <= sect->sh_size - sizeof (* eopt))
14432             {
14433               Elf_External_Options * eoption;
14434
14435               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14436
14437               option->kind = BYTE_GET (eoption->kind);
14438               option->size = BYTE_GET (eoption->size);
14439               option->section = BYTE_GET (eoption->section);
14440               option->info = BYTE_GET (eoption->info);
14441
14442               /* PR 17531: file: ffa0fa3b.  */
14443               if (option->size < sizeof (* eopt)
14444                   || offset + option->size > sect->sh_size)
14445                 {
14446                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14447                   return 0;
14448                 }
14449               offset += option->size;
14450
14451               ++option;
14452               ++cnt;
14453             }
14454
14455           printf (_("\nSection '%s' contains %d entries:\n"),
14456                   printable_section_name (sect), cnt);
14457
14458           option = iopt;
14459           offset = 0;
14460
14461           while (cnt-- > 0)
14462             {
14463               size_t len;
14464
14465               switch (option->kind)
14466                 {
14467                 case ODK_NULL:
14468                   /* This shouldn't happen.  */
14469                   printf (" NULL       %d %lx", option->section, option->info);
14470                   break;
14471                 case ODK_REGINFO:
14472                   printf (" REGINFO    ");
14473                   if (elf_header.e_machine == EM_MIPS)
14474                     {
14475                       /* 32bit form.  */
14476                       Elf32_External_RegInfo * ereg;
14477                       Elf32_RegInfo reginfo;
14478
14479                       ereg = (Elf32_External_RegInfo *) (option + 1);
14480                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14481                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14482                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14483                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14484                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14485                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14486
14487                       printf ("GPR %08lx  GP 0x%lx\n",
14488                               reginfo.ri_gprmask,
14489                               (unsigned long) reginfo.ri_gp_value);
14490                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14491                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14492                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14493                     }
14494                   else
14495                     {
14496                       /* 64 bit form.  */
14497                       Elf64_External_RegInfo * ereg;
14498                       Elf64_Internal_RegInfo reginfo;
14499
14500                       ereg = (Elf64_External_RegInfo *) (option + 1);
14501                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14502                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14503                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14504                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14505                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14506                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14507
14508                       printf ("GPR %08lx  GP 0x",
14509                               reginfo.ri_gprmask);
14510                       printf_vma (reginfo.ri_gp_value);
14511                       printf ("\n");
14512
14513                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14514                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14515                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14516                     }
14517                   ++option;
14518                   continue;
14519                 case ODK_EXCEPTIONS:
14520                   fputs (" EXCEPTIONS fpe_min(", stdout);
14521                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14522                   fputs (") fpe_max(", stdout);
14523                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14524                   fputs (")", stdout);
14525
14526                   if (option->info & OEX_PAGE0)
14527                     fputs (" PAGE0", stdout);
14528                   if (option->info & OEX_SMM)
14529                     fputs (" SMM", stdout);
14530                   if (option->info & OEX_FPDBUG)
14531                     fputs (" FPDBUG", stdout);
14532                   if (option->info & OEX_DISMISS)
14533                     fputs (" DISMISS", stdout);
14534                   break;
14535                 case ODK_PAD:
14536                   fputs (" PAD       ", stdout);
14537                   if (option->info & OPAD_PREFIX)
14538                     fputs (" PREFIX", stdout);
14539                   if (option->info & OPAD_POSTFIX)
14540                     fputs (" POSTFIX", stdout);
14541                   if (option->info & OPAD_SYMBOL)
14542                     fputs (" SYMBOL", stdout);
14543                   break;
14544                 case ODK_HWPATCH:
14545                   fputs (" HWPATCH   ", stdout);
14546                   if (option->info & OHW_R4KEOP)
14547                     fputs (" R4KEOP", stdout);
14548                   if (option->info & OHW_R8KPFETCH)
14549                     fputs (" R8KPFETCH", stdout);
14550                   if (option->info & OHW_R5KEOP)
14551                     fputs (" R5KEOP", stdout);
14552                   if (option->info & OHW_R5KCVTL)
14553                     fputs (" R5KCVTL", stdout);
14554                   break;
14555                 case ODK_FILL:
14556                   fputs (" FILL       ", stdout);
14557                   /* XXX Print content of info word?  */
14558                   break;
14559                 case ODK_TAGS:
14560                   fputs (" TAGS       ", stdout);
14561                   /* XXX Print content of info word?  */
14562                   break;
14563                 case ODK_HWAND:
14564                   fputs (" HWAND     ", stdout);
14565                   if (option->info & OHWA0_R4KEOP_CHECKED)
14566                     fputs (" R4KEOP_CHECKED", stdout);
14567                   if (option->info & OHWA0_R4KEOP_CLEAN)
14568                     fputs (" R4KEOP_CLEAN", stdout);
14569                   break;
14570                 case ODK_HWOR:
14571                   fputs (" HWOR      ", stdout);
14572                   if (option->info & OHWA0_R4KEOP_CHECKED)
14573                     fputs (" R4KEOP_CHECKED", stdout);
14574                   if (option->info & OHWA0_R4KEOP_CLEAN)
14575                     fputs (" R4KEOP_CLEAN", stdout);
14576                   break;
14577                 case ODK_GP_GROUP:
14578                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14579                           option->info & OGP_GROUP,
14580                           (option->info & OGP_SELF) >> 16);
14581                   break;
14582                 case ODK_IDENT:
14583                   printf (" IDENT     %#06lx  self-contained %#06lx",
14584                           option->info & OGP_GROUP,
14585                           (option->info & OGP_SELF) >> 16);
14586                   break;
14587                 default:
14588                   /* This shouldn't happen.  */
14589                   printf (" %3d ???     %d %lx",
14590                           option->kind, option->section, option->info);
14591                   break;
14592                 }
14593
14594               len = sizeof (* eopt);
14595               while (len < option->size)
14596                 {
14597                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
14598
14599                   if (ISPRINT (datum))
14600                     printf ("%c", datum);
14601                   else
14602                     printf ("\\%03o", datum);
14603                   len ++;
14604                 }
14605               fputs ("\n", stdout);
14606
14607               offset += option->size;
14608               ++option;
14609             }
14610
14611           free (eopt);
14612         }
14613     }
14614
14615   if (conflicts_offset != 0 && conflictsno != 0)
14616     {
14617       Elf32_Conflict * iconf;
14618       size_t cnt;
14619
14620       if (dynamic_symbols == NULL)
14621         {
14622           error (_("conflict list found without a dynamic symbol table\n"));
14623           return 0;
14624         }
14625
14626       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14627       if (iconf == NULL)
14628         {
14629           error (_("Out of memory allocating space for dynamic conflicts\n"));
14630           return 0;
14631         }
14632
14633       if (is_32bit_elf)
14634         {
14635           Elf32_External_Conflict * econf32;
14636
14637           econf32 = (Elf32_External_Conflict *)
14638               get_data (NULL, file, conflicts_offset, conflictsno,
14639                         sizeof (* econf32), _("conflict"));
14640           if (!econf32)
14641             return 0;
14642
14643           for (cnt = 0; cnt < conflictsno; ++cnt)
14644             iconf[cnt] = BYTE_GET (econf32[cnt]);
14645
14646           free (econf32);
14647         }
14648       else
14649         {
14650           Elf64_External_Conflict * econf64;
14651
14652           econf64 = (Elf64_External_Conflict *)
14653               get_data (NULL, file, conflicts_offset, conflictsno,
14654                         sizeof (* econf64), _("conflict"));
14655           if (!econf64)
14656             return 0;
14657
14658           for (cnt = 0; cnt < conflictsno; ++cnt)
14659             iconf[cnt] = BYTE_GET (econf64[cnt]);
14660
14661           free (econf64);
14662         }
14663
14664       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14665               (unsigned long) conflictsno);
14666       puts (_("  Num:    Index       Value  Name"));
14667
14668       for (cnt = 0; cnt < conflictsno; ++cnt)
14669         {
14670           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14671
14672           if (iconf[cnt] >= num_dynamic_syms)
14673             printf (_("<corrupt symbol index>"));
14674           else
14675             {
14676               Elf_Internal_Sym * psym;
14677
14678               psym = & dynamic_symbols[iconf[cnt]];
14679               print_vma (psym->st_value, FULL_HEX);
14680               putchar (' ');
14681               if (VALID_DYNAMIC_NAME (psym->st_name))
14682                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14683               else
14684                 printf (_("<corrupt: %14ld>"), psym->st_name);
14685             }
14686           putchar ('\n');
14687         }
14688
14689       free (iconf);
14690     }
14691
14692   if (pltgot != 0 && local_gotno != 0)
14693     {
14694       bfd_vma ent, local_end, global_end;
14695       size_t i, offset;
14696       unsigned char * data;
14697       unsigned char * data_end;
14698       int addr_size;
14699
14700       ent = pltgot;
14701       addr_size = (is_32bit_elf ? 4 : 8);
14702       local_end = pltgot + local_gotno * addr_size;
14703
14704       /* PR binutils/17533 file: 012-111227-0.004  */
14705       if (symtabno < gotsym)
14706         {
14707           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14708                  (unsigned long) gotsym, (unsigned long) symtabno);
14709           return 0;
14710         }
14711
14712       global_end = local_end + (symtabno - gotsym) * addr_size;
14713       /* PR 17531: file: 54c91a34.  */
14714       if (global_end < local_end)
14715         {
14716           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14717           return 0;
14718         }
14719
14720       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14721       data = (unsigned char *) get_data (NULL, file, offset,
14722                                          global_end - pltgot, 1,
14723                                          _("Global Offset Table data"));
14724       if (data == NULL)
14725         return 0;
14726       data_end = data + (global_end - pltgot);
14727
14728       printf (_("\nPrimary GOT:\n"));
14729       printf (_(" Canonical gp value: "));
14730       print_vma (pltgot + 0x7ff0, LONG_HEX);
14731       printf ("\n\n");
14732
14733       printf (_(" Reserved entries:\n"));
14734       printf (_("  %*s %10s %*s Purpose\n"),
14735               addr_size * 2, _("Address"), _("Access"),
14736               addr_size * 2, _("Initial"));
14737       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14738       printf (_(" Lazy resolver\n"));
14739       if (ent == (bfd_vma) -1)
14740         goto got_print_fail;
14741       if (data
14742           && (byte_get (data + ent - pltgot, addr_size)
14743               >> (addr_size * 8 - 1)) != 0)
14744         {
14745           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14746           printf (_(" Module pointer (GNU extension)\n"));
14747           if (ent == (bfd_vma) -1)
14748             goto got_print_fail;
14749         }
14750       printf ("\n");
14751
14752       if (ent < local_end)
14753         {
14754           printf (_(" Local entries:\n"));
14755           printf ("  %*s %10s %*s\n",
14756                   addr_size * 2, _("Address"), _("Access"),
14757                   addr_size * 2, _("Initial"));
14758           while (ent < local_end)
14759             {
14760               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14761               printf ("\n");
14762               if (ent == (bfd_vma) -1)
14763                 goto got_print_fail;
14764             }
14765           printf ("\n");
14766         }
14767
14768       if (gotsym < symtabno)
14769         {
14770           int sym_width;
14771
14772           printf (_(" Global entries:\n"));
14773           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14774                   addr_size * 2, _("Address"),
14775                   _("Access"),
14776                   addr_size * 2, _("Initial"),
14777                   addr_size * 2, _("Sym.Val."),
14778                   _("Type"),
14779                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14780                   _("Ndx"), _("Name"));
14781
14782           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14783
14784           for (i = gotsym; i < symtabno; i++)
14785             {
14786               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14787               printf (" ");
14788
14789               if (dynamic_symbols == NULL)
14790                 printf (_("<no dynamic symbols>"));
14791               else if (i < num_dynamic_syms)
14792                 {
14793                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14794
14795                   print_vma (psym->st_value, LONG_HEX);
14796                   printf (" %-7s %3s ",
14797                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14798                           get_symbol_index_type (psym->st_shndx));
14799
14800                   if (VALID_DYNAMIC_NAME (psym->st_name))
14801                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14802                   else
14803                     printf (_("<corrupt: %14ld>"), psym->st_name);
14804                 }
14805               else
14806                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14807                         (unsigned long) i);
14808
14809               printf ("\n");
14810               if (ent == (bfd_vma) -1)
14811                 break;
14812             }
14813           printf ("\n");
14814         }
14815
14816     got_print_fail:
14817       if (data)
14818         free (data);
14819     }
14820
14821   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14822     {
14823       bfd_vma ent, end;
14824       size_t offset, rel_offset;
14825       unsigned long count, i;
14826       unsigned char * data;
14827       int addr_size, sym_width;
14828       Elf_Internal_Rela * rels;
14829
14830       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14831       if (pltrel == DT_RELA)
14832         {
14833           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14834             return 0;
14835         }
14836       else
14837         {
14838           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14839             return 0;
14840         }
14841
14842       ent = mips_pltgot;
14843       addr_size = (is_32bit_elf ? 4 : 8);
14844       end = mips_pltgot + (2 + count) * addr_size;
14845
14846       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14847       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14848                                          1, _("Procedure Linkage Table data"));
14849       if (data == NULL)
14850         return 0;
14851
14852       printf ("\nPLT GOT:\n\n");
14853       printf (_(" Reserved entries:\n"));
14854       printf (_("  %*s %*s Purpose\n"),
14855               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14856       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14857       printf (_(" PLT lazy resolver\n"));
14858       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14859       printf (_(" Module pointer\n"));
14860       printf ("\n");
14861
14862       printf (_(" Entries:\n"));
14863       printf ("  %*s %*s %*s %-7s %3s %s\n",
14864               addr_size * 2, _("Address"),
14865               addr_size * 2, _("Initial"),
14866               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14867       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14868       for (i = 0; i < count; i++)
14869         {
14870           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14871
14872           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14873           printf (" ");
14874
14875           if (idx >= num_dynamic_syms)
14876             printf (_("<corrupt symbol index: %lu>"), idx);
14877           else
14878             {
14879               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14880
14881               print_vma (psym->st_value, LONG_HEX);
14882               printf (" %-7s %3s ",
14883                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14884                       get_symbol_index_type (psym->st_shndx));
14885               if (VALID_DYNAMIC_NAME (psym->st_name))
14886                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14887               else
14888                 printf (_("<corrupt: %14ld>"), psym->st_name);
14889             }
14890           printf ("\n");
14891         }
14892       printf ("\n");
14893
14894       if (data)
14895         free (data);
14896       free (rels);
14897     }
14898
14899   return 1;
14900 }
14901
14902 static int
14903 process_nds32_specific (FILE * file)
14904 {
14905   Elf_Internal_Shdr *sect = NULL;
14906
14907   sect = find_section (".nds32_e_flags");
14908   if (sect != NULL)
14909     {
14910       unsigned int *flag;
14911
14912       printf ("\nNDS32 elf flags section:\n");
14913       flag = get_data (NULL, file, sect->sh_offset, 1,
14914                        sect->sh_size, _("NDS32 elf flags section"));
14915
14916       switch ((*flag) & 0x3)
14917         {
14918         case 0:
14919           printf ("(VEC_SIZE):\tNo entry.\n");
14920           break;
14921         case 1:
14922           printf ("(VEC_SIZE):\t4 bytes\n");
14923           break;
14924         case 2:
14925           printf ("(VEC_SIZE):\t16 bytes\n");
14926           break;
14927         case 3:
14928           printf ("(VEC_SIZE):\treserved\n");
14929           break;
14930         }
14931     }
14932
14933   return TRUE;
14934 }
14935
14936 static int
14937 process_gnu_liblist (FILE * file)
14938 {
14939   Elf_Internal_Shdr * section;
14940   Elf_Internal_Shdr * string_sec;
14941   Elf32_External_Lib * elib;
14942   char * strtab;
14943   size_t strtab_size;
14944   size_t cnt;
14945   unsigned i;
14946
14947   if (! do_arch)
14948     return 0;
14949
14950   for (i = 0, section = section_headers;
14951        i < elf_header.e_shnum;
14952        i++, section++)
14953     {
14954       switch (section->sh_type)
14955         {
14956         case SHT_GNU_LIBLIST:
14957           if (section->sh_link >= elf_header.e_shnum)
14958             break;
14959
14960           elib = (Elf32_External_Lib *)
14961               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14962                         _("liblist section data"));
14963
14964           if (elib == NULL)
14965             break;
14966           string_sec = section_headers + section->sh_link;
14967
14968           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14969                                       string_sec->sh_size,
14970                                       _("liblist string table"));
14971           if (strtab == NULL
14972               || section->sh_entsize != sizeof (Elf32_External_Lib))
14973             {
14974               free (elib);
14975               free (strtab);
14976               break;
14977             }
14978           strtab_size = string_sec->sh_size;
14979
14980           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14981                   printable_section_name (section),
14982                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14983
14984           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14985
14986           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14987                ++cnt)
14988             {
14989               Elf32_Lib liblist;
14990               time_t atime;
14991               char timebuf[20];
14992               struct tm * tmp;
14993
14994               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14995               atime = BYTE_GET (elib[cnt].l_time_stamp);
14996               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14997               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14998               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14999
15000               tmp = gmtime (&atime);
15001               snprintf (timebuf, sizeof (timebuf),
15002                         "%04u-%02u-%02uT%02u:%02u:%02u",
15003                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15004                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15005
15006               printf ("%3lu: ", (unsigned long) cnt);
15007               if (do_wide)
15008                 printf ("%-20s", liblist.l_name < strtab_size
15009                         ? strtab + liblist.l_name : _("<corrupt>"));
15010               else
15011                 printf ("%-20.20s", liblist.l_name < strtab_size
15012                         ? strtab + liblist.l_name : _("<corrupt>"));
15013               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15014                       liblist.l_version, liblist.l_flags);
15015             }
15016
15017           free (elib);
15018           free (strtab);
15019         }
15020     }
15021
15022   return 1;
15023 }
15024
15025 static const char *
15026 get_note_type (unsigned e_type)
15027 {
15028   static char buff[64];
15029
15030   if (elf_header.e_type == ET_CORE)
15031     switch (e_type)
15032       {
15033       case NT_AUXV:
15034         return _("NT_AUXV (auxiliary vector)");
15035       case NT_PRSTATUS:
15036         return _("NT_PRSTATUS (prstatus structure)");
15037       case NT_FPREGSET:
15038         return _("NT_FPREGSET (floating point registers)");
15039       case NT_PRPSINFO:
15040         return _("NT_PRPSINFO (prpsinfo structure)");
15041       case NT_TASKSTRUCT:
15042         return _("NT_TASKSTRUCT (task structure)");
15043       case NT_PRXFPREG:
15044         return _("NT_PRXFPREG (user_xfpregs structure)");
15045       case NT_PPC_VMX:
15046         return _("NT_PPC_VMX (ppc Altivec registers)");
15047       case NT_PPC_VSX:
15048         return _("NT_PPC_VSX (ppc VSX registers)");
15049       case NT_386_TLS:
15050         return _("NT_386_TLS (x86 TLS information)");
15051       case NT_386_IOPERM:
15052         return _("NT_386_IOPERM (x86 I/O permissions)");
15053       case NT_X86_XSTATE:
15054         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15055       case NT_S390_HIGH_GPRS:
15056         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15057       case NT_S390_TIMER:
15058         return _("NT_S390_TIMER (s390 timer register)");
15059       case NT_S390_TODCMP:
15060         return _("NT_S390_TODCMP (s390 TOD comparator register)");
15061       case NT_S390_TODPREG:
15062         return _("NT_S390_TODPREG (s390 TOD programmable register)");
15063       case NT_S390_CTRS:
15064         return _("NT_S390_CTRS (s390 control registers)");
15065       case NT_S390_PREFIX:
15066         return _("NT_S390_PREFIX (s390 prefix register)");
15067       case NT_S390_LAST_BREAK:
15068         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15069       case NT_S390_SYSTEM_CALL:
15070         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15071       case NT_S390_TDB:
15072         return _("NT_S390_TDB (s390 transaction diagnostic block)");
15073       case NT_S390_VXRS_LOW:
15074         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15075       case NT_S390_VXRS_HIGH:
15076         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15077       case NT_ARM_VFP:
15078         return _("NT_ARM_VFP (arm VFP registers)");
15079       case NT_ARM_TLS:
15080         return _("NT_ARM_TLS (AArch TLS registers)");
15081       case NT_ARM_HW_BREAK:
15082         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15083       case NT_ARM_HW_WATCH:
15084         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15085       case NT_PSTATUS:
15086         return _("NT_PSTATUS (pstatus structure)");
15087       case NT_FPREGS:
15088         return _("NT_FPREGS (floating point registers)");
15089       case NT_PSINFO:
15090         return _("NT_PSINFO (psinfo structure)");
15091       case NT_LWPSTATUS:
15092         return _("NT_LWPSTATUS (lwpstatus_t structure)");
15093       case NT_LWPSINFO:
15094         return _("NT_LWPSINFO (lwpsinfo_t structure)");
15095       case NT_WIN32PSTATUS:
15096         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15097       case NT_SIGINFO:
15098         return _("NT_SIGINFO (siginfo_t data)");
15099       case NT_FILE:
15100         return _("NT_FILE (mapped files)");
15101       default:
15102         break;
15103       }
15104   else
15105     switch (e_type)
15106       {
15107       case NT_VERSION:
15108         return _("NT_VERSION (version)");
15109       case NT_ARCH:
15110         return _("NT_ARCH (architecture)");
15111       default:
15112         break;
15113       }
15114
15115   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15116   return buff;
15117 }
15118
15119 static int
15120 print_core_note (Elf_Internal_Note *pnote)
15121 {
15122   unsigned int addr_size = is_32bit_elf ? 4 : 8;
15123   bfd_vma count, page_size;
15124   unsigned char *descdata, *filenames, *descend;
15125
15126   if (pnote->type != NT_FILE)
15127     return 1;
15128
15129 #ifndef BFD64
15130   if (!is_32bit_elf)
15131     {
15132       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
15133       /* Still "successful".  */
15134       return 1;
15135     }
15136 #endif
15137
15138   if (pnote->descsz < 2 * addr_size)
15139     {
15140       printf (_("    Malformed note - too short for header\n"));
15141       return 0;
15142     }
15143
15144   descdata = (unsigned char *) pnote->descdata;
15145   descend = descdata + pnote->descsz;
15146
15147   if (descdata[pnote->descsz - 1] != '\0')
15148     {
15149       printf (_("    Malformed note - does not end with \\0\n"));
15150       return 0;
15151     }
15152
15153   count = byte_get (descdata, addr_size);
15154   descdata += addr_size;
15155
15156   page_size = byte_get (descdata, addr_size);
15157   descdata += addr_size;
15158
15159   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15160     {
15161       printf (_("    Malformed note - too short for supplied file count\n"));
15162       return 0;
15163     }
15164
15165   printf (_("    Page size: "));
15166   print_vma (page_size, DEC);
15167   printf ("\n");
15168
15169   printf (_("    %*s%*s%*s\n"),
15170           (int) (2 + 2 * addr_size), _("Start"),
15171           (int) (4 + 2 * addr_size), _("End"),
15172           (int) (4 + 2 * addr_size), _("Page Offset"));
15173   filenames = descdata + count * 3 * addr_size;
15174   while (count-- > 0)
15175     {
15176       bfd_vma start, end, file_ofs;
15177
15178       if (filenames == descend)
15179         {
15180           printf (_("    Malformed note - filenames end too early\n"));
15181           return 0;
15182         }
15183
15184       start = byte_get (descdata, addr_size);
15185       descdata += addr_size;
15186       end = byte_get (descdata, addr_size);
15187       descdata += addr_size;
15188       file_ofs = byte_get (descdata, addr_size);
15189       descdata += addr_size;
15190
15191       printf ("    ");
15192       print_vma (start, FULL_HEX);
15193       printf ("  ");
15194       print_vma (end, FULL_HEX);
15195       printf ("  ");
15196       print_vma (file_ofs, FULL_HEX);
15197       printf ("\n        %s\n", filenames);
15198
15199       filenames += 1 + strlen ((char *) filenames);
15200     }
15201
15202   return 1;
15203 }
15204
15205 static const char *
15206 get_gnu_elf_note_type (unsigned e_type)
15207 {
15208   static char buff[64];
15209
15210   switch (e_type)
15211     {
15212     case NT_GNU_ABI_TAG:
15213       return _("NT_GNU_ABI_TAG (ABI version tag)");
15214     case NT_GNU_HWCAP:
15215       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15216     case NT_GNU_BUILD_ID:
15217       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15218     case NT_GNU_GOLD_VERSION:
15219       return _("NT_GNU_GOLD_VERSION (gold version)");
15220     default:
15221       break;
15222     }
15223
15224   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15225   return buff;
15226 }
15227
15228 static int
15229 print_gnu_note (Elf_Internal_Note *pnote)
15230 {
15231   switch (pnote->type)
15232     {
15233     case NT_GNU_BUILD_ID:
15234       {
15235         unsigned long i;
15236
15237         printf (_("    Build ID: "));
15238         for (i = 0; i < pnote->descsz; ++i)
15239           printf ("%02x", pnote->descdata[i] & 0xff);
15240         printf ("\n");
15241       }
15242       break;
15243
15244     case NT_GNU_ABI_TAG:
15245       {
15246         unsigned long os, major, minor, subminor;
15247         const char *osname;
15248
15249         /* PR 17531: file: 030-599401-0.004.  */
15250         if (pnote->descsz < 16)
15251           {
15252             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15253             break;
15254           }
15255
15256         os = byte_get ((unsigned char *) pnote->descdata, 4);
15257         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15258         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15259         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15260
15261         switch (os)
15262           {
15263           case GNU_ABI_TAG_LINUX:
15264             osname = "Linux";
15265             break;
15266           case GNU_ABI_TAG_HURD:
15267             osname = "Hurd";
15268             break;
15269           case GNU_ABI_TAG_SOLARIS:
15270             osname = "Solaris";
15271             break;
15272           case GNU_ABI_TAG_FREEBSD:
15273             osname = "FreeBSD";
15274             break;
15275           case GNU_ABI_TAG_NETBSD:
15276             osname = "NetBSD";
15277             break;
15278           case GNU_ABI_TAG_SYLLABLE:
15279             osname = "Syllable";
15280             break;
15281           case GNU_ABI_TAG_NACL:
15282             osname = "NaCl";
15283             break;
15284           default:
15285             osname = "Unknown";
15286             break;
15287           }
15288
15289         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15290                 major, minor, subminor);
15291       }
15292       break;
15293
15294     case NT_GNU_GOLD_VERSION:
15295       {
15296         unsigned long i;
15297
15298         printf (_("    Version: "));
15299         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15300           printf ("%c", pnote->descdata[i]);
15301         printf ("\n");
15302       }
15303       break;
15304     }
15305
15306   return 1;
15307 }
15308
15309 static const char *
15310 get_v850_elf_note_type (enum v850_notes n_type)
15311 {
15312   static char buff[64];
15313
15314   switch (n_type)
15315     {
15316     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15317     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15318     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15319     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15320     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15321     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15322     default:
15323       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15324       return buff;
15325     }
15326 }
15327
15328 static int
15329 print_v850_note (Elf_Internal_Note * pnote)
15330 {
15331   unsigned int val;
15332
15333   if (pnote->descsz != 4)
15334     return 0;
15335   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15336
15337   if (val == 0)
15338     {
15339       printf (_("not set\n"));
15340       return 1;
15341     }
15342
15343   switch (pnote->type)
15344     {
15345     case V850_NOTE_ALIGNMENT:
15346       switch (val)
15347         {
15348         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15349         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15350         }
15351       break;
15352
15353     case V850_NOTE_DATA_SIZE:
15354       switch (val)
15355         {
15356         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15357         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15358         }
15359       break;
15360
15361     case V850_NOTE_FPU_INFO:
15362       switch (val)
15363         {
15364         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15365         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15366         }
15367       break;
15368
15369     case V850_NOTE_MMU_INFO:
15370     case V850_NOTE_CACHE_INFO:
15371     case V850_NOTE_SIMD_INFO:
15372       if (val == EF_RH850_SIMD)
15373         {
15374           printf (_("yes\n"));
15375           return 1;
15376         }
15377       break;
15378
15379     default:
15380       /* An 'unknown note type' message will already have been displayed.  */
15381       break;
15382     }
15383
15384   printf (_("unknown value: %x\n"), val);
15385   return 0;
15386 }
15387
15388 static int
15389 process_netbsd_elf_note (Elf_Internal_Note * pnote)
15390 {
15391   unsigned int version;
15392
15393   switch (pnote->type)
15394     {
15395     case NT_NETBSD_IDENT:
15396       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15397       if ((version / 10000) % 100)
15398         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15399                 version, version / 100000000, (version / 1000000) % 100,
15400                 (version / 10000) % 100 > 26 ? "Z" : "",
15401                 'A' + (version / 10000) % 26);
15402       else
15403         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15404                 version, version / 100000000, (version / 1000000) % 100,
15405                 (version / 100) % 100);
15406       return 1;
15407
15408     case NT_NETBSD_MARCH:
15409       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15410               pnote->descdata);
15411       return 1;
15412
15413     default:
15414       break;
15415     }
15416
15417   printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15418           pnote->type);
15419   return 1;
15420 }
15421
15422 static const char *
15423 get_freebsd_elfcore_note_type (unsigned e_type)
15424 {
15425   switch (e_type)
15426     {
15427     case NT_FREEBSD_THRMISC:
15428       return _("NT_THRMISC (thrmisc structure)");
15429     case NT_FREEBSD_PROCSTAT_PROC:
15430       return _("NT_PROCSTAT_PROC (proc data)");
15431     case NT_FREEBSD_PROCSTAT_FILES:
15432       return _("NT_PROCSTAT_FILES (files data)");
15433     case NT_FREEBSD_PROCSTAT_VMMAP:
15434       return _("NT_PROCSTAT_VMMAP (vmmap data)");
15435     case NT_FREEBSD_PROCSTAT_GROUPS:
15436       return _("NT_PROCSTAT_GROUPS (groups data)");
15437     case NT_FREEBSD_PROCSTAT_UMASK:
15438       return _("NT_PROCSTAT_UMASK (umask data)");
15439     case NT_FREEBSD_PROCSTAT_RLIMIT:
15440       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15441     case NT_FREEBSD_PROCSTAT_OSREL:
15442       return _("NT_PROCSTAT_OSREL (osreldate data)");
15443     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15444       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15445     case NT_FREEBSD_PROCSTAT_AUXV:
15446       return _("NT_PROCSTAT_AUXV (auxv data)");
15447     }
15448   return get_note_type (e_type);
15449 }
15450
15451 static const char *
15452 get_netbsd_elfcore_note_type (unsigned e_type)
15453 {
15454   static char buff[64];
15455
15456   if (e_type == NT_NETBSDCORE_PROCINFO)
15457     {
15458       /* NetBSD core "procinfo" structure.  */
15459       return _("NetBSD procinfo structure");
15460     }
15461
15462   /* As of Jan 2002 there are no other machine-independent notes
15463      defined for NetBSD core files.  If the note type is less
15464      than the start of the machine-dependent note types, we don't
15465      understand it.  */
15466
15467   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15468     {
15469       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15470       return buff;
15471     }
15472
15473   switch (elf_header.e_machine)
15474     {
15475     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15476        and PT_GETFPREGS == mach+2.  */
15477
15478     case EM_OLD_ALPHA:
15479     case EM_ALPHA:
15480     case EM_SPARC:
15481     case EM_SPARC32PLUS:
15482     case EM_SPARCV9:
15483       switch (e_type)
15484         {
15485         case NT_NETBSDCORE_FIRSTMACH + 0:
15486           return _("PT_GETREGS (reg structure)");
15487         case NT_NETBSDCORE_FIRSTMACH + 2:
15488           return _("PT_GETFPREGS (fpreg structure)");
15489         default:
15490           break;
15491         }
15492       break;
15493
15494     /* On all other arch's, PT_GETREGS == mach+1 and
15495        PT_GETFPREGS == mach+3.  */
15496     default:
15497       switch (e_type)
15498         {
15499         case NT_NETBSDCORE_FIRSTMACH + 1:
15500           return _("PT_GETREGS (reg structure)");
15501         case NT_NETBSDCORE_FIRSTMACH + 3:
15502           return _("PT_GETFPREGS (fpreg structure)");
15503         default:
15504           break;
15505         }
15506     }
15507
15508   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15509             e_type - NT_NETBSDCORE_FIRSTMACH);
15510   return buff;
15511 }
15512
15513 static const char *
15514 get_stapsdt_note_type (unsigned e_type)
15515 {
15516   static char buff[64];
15517
15518   switch (e_type)
15519     {
15520     case NT_STAPSDT:
15521       return _("NT_STAPSDT (SystemTap probe descriptors)");
15522
15523     default:
15524       break;
15525     }
15526
15527   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15528   return buff;
15529 }
15530
15531 static int
15532 print_stapsdt_note (Elf_Internal_Note *pnote)
15533 {
15534   int addr_size = is_32bit_elf ? 4 : 8;
15535   char *data = pnote->descdata;
15536   char *data_end = pnote->descdata + pnote->descsz;
15537   bfd_vma pc, base_addr, semaphore;
15538   char *provider, *probe, *arg_fmt;
15539
15540   pc = byte_get ((unsigned char *) data, addr_size);
15541   data += addr_size;
15542   base_addr = byte_get ((unsigned char *) data, addr_size);
15543   data += addr_size;
15544   semaphore = byte_get ((unsigned char *) data, addr_size);
15545   data += addr_size;
15546
15547   provider = data;
15548   data += strlen (data) + 1;
15549   probe = data;
15550   data += strlen (data) + 1;
15551   arg_fmt = data;
15552   data += strlen (data) + 1;
15553
15554   printf (_("    Provider: %s\n"), provider);
15555   printf (_("    Name: %s\n"), probe);
15556   printf (_("    Location: "));
15557   print_vma (pc, FULL_HEX);
15558   printf (_(", Base: "));
15559   print_vma (base_addr, FULL_HEX);
15560   printf (_(", Semaphore: "));
15561   print_vma (semaphore, FULL_HEX);
15562   printf ("\n");
15563   printf (_("    Arguments: %s\n"), arg_fmt);
15564
15565   return data == data_end;
15566 }
15567
15568 static const char *
15569 get_ia64_vms_note_type (unsigned e_type)
15570 {
15571   static char buff[64];
15572
15573   switch (e_type)
15574     {
15575     case NT_VMS_MHD:
15576       return _("NT_VMS_MHD (module header)");
15577     case NT_VMS_LNM:
15578       return _("NT_VMS_LNM (language name)");
15579     case NT_VMS_SRC:
15580       return _("NT_VMS_SRC (source files)");
15581     case NT_VMS_TITLE:
15582       return "NT_VMS_TITLE";
15583     case NT_VMS_EIDC:
15584       return _("NT_VMS_EIDC (consistency check)");
15585     case NT_VMS_FPMODE:
15586       return _("NT_VMS_FPMODE (FP mode)");
15587     case NT_VMS_LINKTIME:
15588       return "NT_VMS_LINKTIME";
15589     case NT_VMS_IMGNAM:
15590       return _("NT_VMS_IMGNAM (image name)");
15591     case NT_VMS_IMGID:
15592       return _("NT_VMS_IMGID (image id)");
15593     case NT_VMS_LINKID:
15594       return _("NT_VMS_LINKID (link id)");
15595     case NT_VMS_IMGBID:
15596       return _("NT_VMS_IMGBID (build id)");
15597     case NT_VMS_GSTNAM:
15598       return _("NT_VMS_GSTNAM (sym table name)");
15599     case NT_VMS_ORIG_DYN:
15600       return "NT_VMS_ORIG_DYN";
15601     case NT_VMS_PATCHTIME:
15602       return "NT_VMS_PATCHTIME";
15603     default:
15604       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15605       return buff;
15606     }
15607 }
15608
15609 static int
15610 print_ia64_vms_note (Elf_Internal_Note * pnote)
15611 {
15612   switch (pnote->type)
15613     {
15614     case NT_VMS_MHD:
15615       if (pnote->descsz > 36)
15616         {
15617           size_t l = strlen (pnote->descdata + 34);
15618           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15619           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15620           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15621           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15622         }
15623       else
15624         printf (_("    Invalid size\n"));
15625       break;
15626     case NT_VMS_LNM:
15627       printf (_("   Language: %s\n"), pnote->descdata);
15628       break;
15629 #ifdef BFD64
15630     case NT_VMS_FPMODE:
15631       printf (_("   Floating Point mode: "));
15632       printf ("0x%016" BFD_VMA_FMT "x\n",
15633               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15634       break;
15635     case NT_VMS_LINKTIME:
15636       printf (_("   Link time: "));
15637       print_vms_time
15638         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15639       printf ("\n");
15640       break;
15641     case NT_VMS_PATCHTIME:
15642       printf (_("   Patch time: "));
15643       print_vms_time
15644         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15645       printf ("\n");
15646       break;
15647     case NT_VMS_ORIG_DYN:
15648       printf (_("   Major id: %u,  minor id: %u\n"),
15649               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15650               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15651       printf (_("   Last modified  : "));
15652       print_vms_time
15653         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15654       printf (_("\n   Link flags  : "));
15655       printf ("0x%016" BFD_VMA_FMT "x\n",
15656               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15657       printf (_("   Header flags: 0x%08x\n"),
15658               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15659       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15660       break;
15661 #endif
15662     case NT_VMS_IMGNAM:
15663       printf (_("    Image name: %s\n"), pnote->descdata);
15664       break;
15665     case NT_VMS_GSTNAM:
15666       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15667       break;
15668     case NT_VMS_IMGID:
15669       printf (_("    Image id: %s\n"), pnote->descdata);
15670       break;
15671     case NT_VMS_LINKID:
15672       printf (_("    Linker id: %s\n"), pnote->descdata);
15673       break;
15674     default:
15675       break;
15676     }
15677   return 1;
15678 }
15679
15680 /* Note that by the ELF standard, the name field is already null byte
15681    terminated, and namesz includes the terminating null byte.
15682    I.E. the value of namesz for the name "FSF" is 4.
15683
15684    If the value of namesz is zero, there is no name present.  */
15685 static int
15686 process_note (Elf_Internal_Note * pnote)
15687 {
15688   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15689   const char * nt;
15690
15691   if (pnote->namesz == 0)
15692     /* If there is no note name, then use the default set of
15693        note type strings.  */
15694     nt = get_note_type (pnote->type);
15695
15696   else if (const_strneq (pnote->namedata, "GNU"))
15697     /* GNU-specific object file notes.  */
15698     nt = get_gnu_elf_note_type (pnote->type);
15699
15700   else if (const_strneq (pnote->namedata, "FreeBSD"))
15701     /* FreeBSD-specific core file notes.  */
15702     nt = get_freebsd_elfcore_note_type (pnote->type);
15703
15704   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15705     /* NetBSD-specific core file notes.  */
15706     nt = get_netbsd_elfcore_note_type (pnote->type);
15707
15708   else if (const_strneq (pnote->namedata, "NetBSD"))
15709     /* NetBSD-specific core file notes.  */
15710     return process_netbsd_elf_note (pnote);
15711
15712   else if (strneq (pnote->namedata, "SPU/", 4))
15713     {
15714       /* SPU-specific core file notes.  */
15715       nt = pnote->namedata + 4;
15716       name = "SPU";
15717     }
15718
15719   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15720     /* VMS/ia64-specific file notes.  */
15721     nt = get_ia64_vms_note_type (pnote->type);
15722
15723   else if (const_strneq (pnote->namedata, "stapsdt"))
15724     nt = get_stapsdt_note_type (pnote->type);
15725
15726   else
15727     /* Don't recognize this note name; just use the default set of
15728        note type strings.  */
15729     nt = get_note_type (pnote->type);
15730
15731   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15732
15733   if (const_strneq (pnote->namedata, "IPF/VMS"))
15734     return print_ia64_vms_note (pnote);
15735   else if (const_strneq (pnote->namedata, "GNU"))
15736     return print_gnu_note (pnote);
15737   else if (const_strneq (pnote->namedata, "stapsdt"))
15738     return print_stapsdt_note (pnote);
15739   else if (const_strneq (pnote->namedata, "CORE"))
15740     return print_core_note (pnote);
15741   else
15742     return 1;
15743 }
15744
15745
15746 static int
15747 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15748 {
15749   Elf_External_Note * pnotes;
15750   Elf_External_Note * external;
15751   char * end;
15752   int res = 1;
15753
15754   if (length <= 0)
15755     return 0;
15756
15757   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15758                                            _("notes"));
15759   if (pnotes == NULL)
15760     return 0;
15761
15762   external = pnotes;
15763
15764   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15765           (unsigned long) offset, (unsigned long) length);
15766   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15767
15768   end = (char *) pnotes + length;
15769   while ((char *) external < end)
15770     {
15771       Elf_Internal_Note inote;
15772       size_t min_notesz;
15773       char *next;
15774       char * temp = NULL;
15775       size_t data_remaining = end - (char *) external;
15776
15777       if (!is_ia64_vms ())
15778         {
15779           /* PR binutils/15191
15780              Make sure that there is enough data to read.  */
15781           min_notesz = offsetof (Elf_External_Note, name);
15782           if (data_remaining < min_notesz)
15783             {
15784               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15785                     (int) data_remaining);
15786               break;
15787             }
15788           inote.type     = BYTE_GET (external->type);
15789           inote.namesz   = BYTE_GET (external->namesz);
15790           inote.namedata = external->name;
15791           inote.descsz   = BYTE_GET (external->descsz);
15792           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15793           /* PR 17531: file: 3443835e.  */
15794           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15795             {
15796               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15797               inote.descdata = inote.namedata;
15798               inote.namesz   = 0;
15799             }
15800
15801           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15802           next = inote.descdata + align_power (inote.descsz, 2);
15803         }
15804       else
15805         {
15806           Elf64_External_VMS_Note *vms_external;
15807
15808           /* PR binutils/15191
15809              Make sure that there is enough data to read.  */
15810           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15811           if (data_remaining < min_notesz)
15812             {
15813               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15814                     (int) data_remaining);
15815               break;
15816             }
15817
15818           vms_external = (Elf64_External_VMS_Note *) external;
15819           inote.type     = BYTE_GET (vms_external->type);
15820           inote.namesz   = BYTE_GET (vms_external->namesz);
15821           inote.namedata = vms_external->name;
15822           inote.descsz   = BYTE_GET (vms_external->descsz);
15823           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15824           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15825           next = inote.descdata + align_power (inote.descsz, 3);
15826         }
15827
15828       if (inote.descdata < (char *) external + min_notesz
15829           || next < (char *) external + min_notesz
15830           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15831           || inote.namedata + inote.namesz < inote.namedata
15832           || inote.descdata + inote.descsz < inote.descdata
15833           || data_remaining < (size_t)(next - (char *) external))
15834         {
15835           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15836                 (unsigned long) ((char *) external - (char *) pnotes));
15837           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15838                 inote.type, inote.namesz, inote.descsz);
15839           break;
15840         }
15841
15842       external = (Elf_External_Note *) next;
15843
15844       /* Verify that name is null terminated.  It appears that at least
15845          one version of Linux (RedHat 6.0) generates corefiles that don't
15846          comply with the ELF spec by failing to include the null byte in
15847          namesz.  */
15848       if (inote.namedata[inote.namesz - 1] != '\0')
15849         {
15850           temp = (char *) malloc (inote.namesz + 1);
15851           if (temp == NULL)
15852             {
15853               error (_("Out of memory allocating space for inote name\n"));
15854               res = 0;
15855               break;
15856             }
15857
15858           strncpy (temp, inote.namedata, inote.namesz);
15859           temp[inote.namesz] = 0;
15860
15861           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15862           inote.namedata = temp;
15863         }
15864
15865       res &= process_note (& inote);
15866
15867       if (temp != NULL)
15868         {
15869           free (temp);
15870           temp = NULL;
15871         }
15872     }
15873
15874   free (pnotes);
15875
15876   return res;
15877 }
15878
15879 static int
15880 process_corefile_note_segments (FILE * file)
15881 {
15882   Elf_Internal_Phdr * segment;
15883   unsigned int i;
15884   int res = 1;
15885
15886   if (! get_program_headers (file))
15887       return 0;
15888
15889   for (i = 0, segment = program_headers;
15890        i < elf_header.e_phnum;
15891        i++, segment++)
15892     {
15893       if (segment->p_type == PT_NOTE)
15894         res &= process_corefile_note_segment (file,
15895                                               (bfd_vma) segment->p_offset,
15896                                               (bfd_vma) segment->p_filesz);
15897     }
15898
15899   return res;
15900 }
15901
15902 static int
15903 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15904 {
15905   Elf_External_Note * pnotes;
15906   Elf_External_Note * external;
15907   char * end;
15908   int res = 1;
15909
15910   if (length <= 0)
15911     return 0;
15912
15913   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15914                                            _("v850 notes"));
15915   if (pnotes == NULL)
15916     return 0;
15917
15918   external = pnotes;
15919   end = (char*) pnotes + length;
15920
15921   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15922           (unsigned long) offset, (unsigned long) length);
15923
15924   while ((char *) external + sizeof (Elf_External_Note) < end)
15925     {
15926       Elf_External_Note * next;
15927       Elf_Internal_Note inote;
15928
15929       inote.type     = BYTE_GET (external->type);
15930       inote.namesz   = BYTE_GET (external->namesz);
15931       inote.namedata = external->name;
15932       inote.descsz   = BYTE_GET (external->descsz);
15933       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15934       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15935
15936       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15937         {
15938           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15939           inote.descdata = inote.namedata;
15940           inote.namesz   = 0;
15941         }
15942
15943       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15944
15945       if (   ((char *) next > end)
15946           || ((char *) next <  (char *) pnotes))
15947         {
15948           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15949                 (unsigned long) ((char *) external - (char *) pnotes));
15950           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15951                 inote.type, inote.namesz, inote.descsz);
15952           break;
15953         }
15954
15955       external = next;
15956
15957       /* Prevent out-of-bounds indexing.  */
15958       if (   inote.namedata + inote.namesz > end
15959           || inote.namedata + inote.namesz < inote.namedata)
15960         {
15961           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15962                 (unsigned long) ((char *) external - (char *) pnotes));
15963           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15964                 inote.type, inote.namesz, inote.descsz);
15965           break;
15966         }
15967
15968       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15969
15970       if (! print_v850_note (& inote))
15971         {
15972           res = 0;
15973           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15974                   inote.namesz, inote.descsz);
15975         }
15976     }
15977
15978   free (pnotes);
15979
15980   return res;
15981 }
15982
15983 static int
15984 process_note_sections (FILE * file)
15985 {
15986   Elf_Internal_Shdr * section;
15987   unsigned long i;
15988   int n = 0;
15989   int res = 1;
15990
15991   for (i = 0, section = section_headers;
15992        i < elf_header.e_shnum && section != NULL;
15993        i++, section++)
15994     {
15995       if (section->sh_type == SHT_NOTE)
15996         {
15997           res &= process_corefile_note_segment (file,
15998                                                 (bfd_vma) section->sh_offset,
15999                                                 (bfd_vma) section->sh_size);
16000           n++;
16001         }
16002
16003       if ((   elf_header.e_machine == EM_V800
16004            || elf_header.e_machine == EM_V850
16005            || elf_header.e_machine == EM_CYGNUS_V850)
16006           && section->sh_type == SHT_RENESAS_INFO)
16007         {
16008           res &= process_v850_notes (file,
16009                                      (bfd_vma) section->sh_offset,
16010                                      (bfd_vma) section->sh_size);
16011           n++;
16012         }
16013     }
16014
16015   if (n == 0)
16016     /* Try processing NOTE segments instead.  */
16017     return process_corefile_note_segments (file);
16018
16019   return res;
16020 }
16021
16022 static int
16023 process_notes (FILE * file)
16024 {
16025   /* If we have not been asked to display the notes then do nothing.  */
16026   if (! do_notes)
16027     return 1;
16028
16029   if (elf_header.e_type != ET_CORE)
16030     return process_note_sections (file);
16031
16032   /* No program headers means no NOTE segment.  */
16033   if (elf_header.e_phnum > 0)
16034     return process_corefile_note_segments (file);
16035
16036   printf (_("No note segments present in the core file.\n"));
16037   return 1;
16038 }
16039
16040 static int
16041 process_arch_specific (FILE * file)
16042 {
16043   if (! do_arch)
16044     return 1;
16045
16046   switch (elf_header.e_machine)
16047     {
16048     case EM_ARM:
16049       return process_arm_specific (file);
16050     case EM_MIPS:
16051     case EM_MIPS_RS3_LE:
16052       return process_mips_specific (file);
16053       break;
16054     case EM_NDS32:
16055       return process_nds32_specific (file);
16056       break;
16057     case EM_PPC:
16058       return process_power_specific (file);
16059       break;
16060     case EM_S390:
16061     case EM_S390_OLD:
16062       return process_s390_specific (file);
16063       break;
16064     case EM_SPARC:
16065     case EM_SPARC32PLUS:
16066     case EM_SPARCV9:
16067       return process_sparc_specific (file);
16068       break;
16069     case EM_TI_C6000:
16070       return process_tic6x_specific (file);
16071       break;
16072     case EM_MSP430:
16073       return process_msp430x_specific (file);
16074     default:
16075       break;
16076     }
16077   return 1;
16078 }
16079
16080 static int
16081 get_file_header (FILE * file)
16082 {
16083   /* Read in the identity array.  */
16084   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
16085     return 0;
16086
16087   /* Determine how to read the rest of the header.  */
16088   switch (elf_header.e_ident[EI_DATA])
16089     {
16090     default: /* fall through */
16091     case ELFDATANONE: /* fall through */
16092     case ELFDATA2LSB:
16093       byte_get = byte_get_little_endian;
16094       byte_put = byte_put_little_endian;
16095       break;
16096     case ELFDATA2MSB:
16097       byte_get = byte_get_big_endian;
16098       byte_put = byte_put_big_endian;
16099       break;
16100     }
16101
16102   /* For now we only support 32 bit and 64 bit ELF files.  */
16103   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
16104
16105   /* Read in the rest of the header.  */
16106   if (is_32bit_elf)
16107     {
16108       Elf32_External_Ehdr ehdr32;
16109
16110       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16111         return 0;
16112
16113       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
16114       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
16115       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
16116       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
16117       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
16118       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
16119       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
16120       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
16121       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16122       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
16123       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16124       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
16125       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
16126     }
16127   else
16128     {
16129       Elf64_External_Ehdr ehdr64;
16130
16131       /* If we have been compiled with sizeof (bfd_vma) == 4, then
16132          we will not be able to cope with the 64bit data found in
16133          64 ELF files.  Detect this now and abort before we start
16134          overwriting things.  */
16135       if (sizeof (bfd_vma) < 8)
16136         {
16137           error (_("This instance of readelf has been built without support for a\n\
16138 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16139           return 0;
16140         }
16141
16142       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16143         return 0;
16144
16145       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
16146       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
16147       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
16148       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
16149       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
16150       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
16151       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
16152       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
16153       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16154       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
16155       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16156       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
16157       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
16158     }
16159
16160   if (elf_header.e_shoff)
16161     {
16162       /* There may be some extensions in the first section header.  Don't
16163          bomb if we can't read it.  */
16164       if (is_32bit_elf)
16165         get_32bit_section_headers (file, TRUE);
16166       else
16167         get_64bit_section_headers (file, TRUE);
16168     }
16169
16170   return 1;
16171 }
16172
16173 /* Process one ELF object file according to the command line options.
16174    This file may actually be stored in an archive.  The file is
16175    positioned at the start of the ELF object.  */
16176
16177 static int
16178 process_object (char * file_name, FILE * file)
16179 {
16180   unsigned int i;
16181
16182   if (! get_file_header (file))
16183     {
16184       error (_("%s: Failed to read file header\n"), file_name);
16185       return 1;
16186     }
16187
16188   /* Initialise per file variables.  */
16189   for (i = ARRAY_SIZE (version_info); i--;)
16190     version_info[i] = 0;
16191
16192   for (i = ARRAY_SIZE (dynamic_info); i--;)
16193     dynamic_info[i] = 0;
16194   dynamic_info_DT_GNU_HASH = 0;
16195
16196   /* Process the file.  */
16197   if (show_name)
16198     printf (_("\nFile: %s\n"), file_name);
16199
16200   /* Initialise the dump_sects array from the cmdline_dump_sects array.
16201      Note we do this even if cmdline_dump_sects is empty because we
16202      must make sure that the dump_sets array is zeroed out before each
16203      object file is processed.  */
16204   if (num_dump_sects > num_cmdline_dump_sects)
16205     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
16206
16207   if (num_cmdline_dump_sects > 0)
16208     {
16209       if (num_dump_sects == 0)
16210         /* A sneaky way of allocating the dump_sects array.  */
16211         request_dump_bynumber (num_cmdline_dump_sects, 0);
16212
16213       assert (num_dump_sects >= num_cmdline_dump_sects);
16214       memcpy (dump_sects, cmdline_dump_sects,
16215               num_cmdline_dump_sects * sizeof (* dump_sects));
16216     }
16217
16218   if (! process_file_header ())
16219     return 1;
16220
16221   if (! process_section_headers (file))
16222     {
16223       /* Without loaded section headers we cannot process lots of
16224          things.  */
16225       do_unwind = do_version = do_dump = do_arch = 0;
16226
16227       if (! do_using_dynamic)
16228         do_syms = do_dyn_syms = do_reloc = 0;
16229     }
16230
16231   if (! process_section_groups (file))
16232     {
16233       /* Without loaded section groups we cannot process unwind.  */
16234       do_unwind = 0;
16235     }
16236
16237   if (process_program_headers (file))
16238     process_dynamic_section (file);
16239
16240   process_relocs (file);
16241
16242   process_unwind (file);
16243
16244   process_symbol_table (file);
16245
16246   process_syminfo (file);
16247
16248   process_version_sections (file);
16249
16250   process_section_contents (file);
16251
16252   process_notes (file);
16253
16254   process_gnu_liblist (file);
16255
16256   process_arch_specific (file);
16257
16258   if (program_headers)
16259     {
16260       free (program_headers);
16261       program_headers = NULL;
16262     }
16263
16264   if (section_headers)
16265     {
16266       free (section_headers);
16267       section_headers = NULL;
16268     }
16269
16270   if (string_table)
16271     {
16272       free (string_table);
16273       string_table = NULL;
16274       string_table_length = 0;
16275     }
16276
16277   if (dynamic_strings)
16278     {
16279       free (dynamic_strings);
16280       dynamic_strings = NULL;
16281       dynamic_strings_length = 0;
16282     }
16283
16284   if (dynamic_symbols)
16285     {
16286       free (dynamic_symbols);
16287       dynamic_symbols = NULL;
16288       num_dynamic_syms = 0;
16289     }
16290
16291   if (dynamic_syminfo)
16292     {
16293       free (dynamic_syminfo);
16294       dynamic_syminfo = NULL;
16295     }
16296
16297   if (dynamic_section)
16298     {
16299       free (dynamic_section);
16300       dynamic_section = NULL;
16301     }
16302
16303   if (section_headers_groups)
16304     {
16305       free (section_headers_groups);
16306       section_headers_groups = NULL;
16307     }
16308
16309   if (section_groups)
16310     {
16311       struct group_list * g;
16312       struct group_list * next;
16313
16314       for (i = 0; i < group_count; i++)
16315         {
16316           for (g = section_groups [i].root; g != NULL; g = next)
16317             {
16318               next = g->next;
16319               free (g);
16320             }
16321         }
16322
16323       free (section_groups);
16324       section_groups = NULL;
16325     }
16326
16327   free_debug_memory ();
16328
16329   return 0;
16330 }
16331
16332 /* Process an ELF archive.
16333    On entry the file is positioned just after the ARMAG string.  */
16334
16335 static int
16336 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16337 {
16338   struct archive_info arch;
16339   struct archive_info nested_arch;
16340   size_t got;
16341   int ret;
16342
16343   show_name = 1;
16344
16345   /* The ARCH structure is used to hold information about this archive.  */
16346   arch.file_name = NULL;
16347   arch.file = NULL;
16348   arch.index_array = NULL;
16349   arch.sym_table = NULL;
16350   arch.longnames = NULL;
16351
16352   /* The NESTED_ARCH structure is used as a single-item cache of information
16353      about a nested archive (when members of a thin archive reside within
16354      another regular archive file).  */
16355   nested_arch.file_name = NULL;
16356   nested_arch.file = NULL;
16357   nested_arch.index_array = NULL;
16358   nested_arch.sym_table = NULL;
16359   nested_arch.longnames = NULL;
16360
16361   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16362     {
16363       ret = 1;
16364       goto out;
16365     }
16366
16367   if (do_archive_index)
16368     {
16369       if (arch.sym_table == NULL)
16370         error (_("%s: unable to dump the index as none was found\n"), file_name);
16371       else
16372         {
16373           unsigned long i, l;
16374           unsigned long current_pos;
16375
16376           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16377                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16378           current_pos = ftell (file);
16379
16380           for (i = l = 0; i < arch.index_num; i++)
16381             {
16382               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16383                 {
16384                   char * member_name;
16385
16386                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16387
16388                   if (member_name != NULL)
16389                     {
16390                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16391
16392                       if (qualified_name != NULL)
16393                         {
16394                           printf (_("Contents of binary %s at offset "), qualified_name);
16395                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16396                           putchar ('\n');
16397                           free (qualified_name);
16398                         }
16399                     }
16400                 }
16401
16402               if (l >= arch.sym_size)
16403                 {
16404                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16405                          file_name);
16406                   break;
16407                 }
16408               /* PR 17531: file: 0b6630b2.  */
16409               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16410               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16411             }
16412
16413           if (arch.uses_64bit_indicies)
16414             l = (l + 7) & ~ 7;
16415           else
16416             l += l & 1;
16417
16418           if (l < arch.sym_size)
16419             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16420                    file_name, arch.sym_size - l);
16421
16422           if (fseek (file, current_pos, SEEK_SET) != 0)
16423             {
16424               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16425               ret = 1;
16426               goto out;
16427             }
16428         }
16429
16430       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16431           && !do_segments && !do_header && !do_dump && !do_version
16432           && !do_histogram && !do_debugging && !do_arch && !do_notes
16433           && !do_section_groups && !do_dyn_syms)
16434         {
16435           ret = 0; /* Archive index only.  */
16436           goto out;
16437         }
16438     }
16439
16440   ret = 0;
16441
16442   while (1)
16443     {
16444       char * name;
16445       size_t namelen;
16446       char * qualified_name;
16447
16448       /* Read the next archive header.  */
16449       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16450         {
16451           error (_("%s: failed to seek to next archive header\n"), file_name);
16452           return 1;
16453         }
16454       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16455       if (got != sizeof arch.arhdr)
16456         {
16457           if (got == 0)
16458             break;
16459           error (_("%s: failed to read archive header\n"), file_name);
16460           ret = 1;
16461           break;
16462         }
16463       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16464         {
16465           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16466           ret = 1;
16467           break;
16468         }
16469
16470       arch.next_arhdr_offset += sizeof arch.arhdr;
16471
16472       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16473       if (archive_file_size & 01)
16474         ++archive_file_size;
16475
16476       name = get_archive_member_name (&arch, &nested_arch);
16477       if (name == NULL)
16478         {
16479           error (_("%s: bad archive file name\n"), file_name);
16480           ret = 1;
16481           break;
16482         }
16483       namelen = strlen (name);
16484
16485       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16486       if (qualified_name == NULL)
16487         {
16488           error (_("%s: bad archive file name\n"), file_name);
16489           ret = 1;
16490           break;
16491         }
16492
16493       if (is_thin_archive && arch.nested_member_origin == 0)
16494         {
16495           /* This is a proxy for an external member of a thin archive.  */
16496           FILE * member_file;
16497           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16498           if (member_file_name == NULL)
16499             {
16500               ret = 1;
16501               break;
16502             }
16503
16504           member_file = fopen (member_file_name, "rb");
16505           if (member_file == NULL)
16506             {
16507               error (_("Input file '%s' is not readable.\n"), member_file_name);
16508               free (member_file_name);
16509               ret = 1;
16510               break;
16511             }
16512
16513           archive_file_offset = arch.nested_member_origin;
16514
16515           ret |= process_object (qualified_name, member_file);
16516
16517           fclose (member_file);
16518           free (member_file_name);
16519         }
16520       else if (is_thin_archive)
16521         {
16522           /* PR 15140: Allow for corrupt thin archives.  */
16523           if (nested_arch.file == NULL)
16524             {
16525               error (_("%s: contains corrupt thin archive: %s\n"),
16526                      file_name, name);
16527               ret = 1;
16528               break;
16529             }
16530
16531           /* This is a proxy for a member of a nested archive.  */
16532           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16533
16534           /* The nested archive file will have been opened and setup by
16535              get_archive_member_name.  */
16536           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16537             {
16538               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16539               ret = 1;
16540               break;
16541             }
16542
16543           ret |= process_object (qualified_name, nested_arch.file);
16544         }
16545       else
16546         {
16547           archive_file_offset = arch.next_arhdr_offset;
16548           arch.next_arhdr_offset += archive_file_size;
16549
16550           ret |= process_object (qualified_name, file);
16551         }
16552
16553       if (dump_sects != NULL)
16554         {
16555           free (dump_sects);
16556           dump_sects = NULL;
16557           num_dump_sects = 0;
16558         }
16559
16560       free (qualified_name);
16561     }
16562
16563  out:
16564   if (nested_arch.file != NULL)
16565     fclose (nested_arch.file);
16566   release_archive (&nested_arch);
16567   release_archive (&arch);
16568
16569   return ret;
16570 }
16571
16572 static int
16573 process_file (char * file_name)
16574 {
16575   FILE * file;
16576   struct stat statbuf;
16577   char armag[SARMAG];
16578   int ret;
16579
16580   if (stat (file_name, &statbuf) < 0)
16581     {
16582       if (errno == ENOENT)
16583         error (_("'%s': No such file\n"), file_name);
16584       else
16585         error (_("Could not locate '%s'.  System error message: %s\n"),
16586                file_name, strerror (errno));
16587       return 1;
16588     }
16589
16590   if (! S_ISREG (statbuf.st_mode))
16591     {
16592       error (_("'%s' is not an ordinary file\n"), file_name);
16593       return 1;
16594     }
16595
16596   file = fopen (file_name, "rb");
16597   if (file == NULL)
16598     {
16599       error (_("Input file '%s' is not readable.\n"), file_name);
16600       return 1;
16601     }
16602
16603   if (fread (armag, SARMAG, 1, file) != 1)
16604     {
16605       error (_("%s: Failed to read file's magic number\n"), file_name);
16606       fclose (file);
16607       return 1;
16608     }
16609
16610   current_file_size = (bfd_size_type) statbuf.st_size;
16611
16612   if (memcmp (armag, ARMAG, SARMAG) == 0)
16613     ret = process_archive (file_name, file, FALSE);
16614   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16615     ret = process_archive (file_name, file, TRUE);
16616   else
16617     {
16618       if (do_archive_index)
16619         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16620                file_name);
16621
16622       rewind (file);
16623       archive_file_size = archive_file_offset = 0;
16624       ret = process_object (file_name, file);
16625     }
16626
16627   fclose (file);
16628
16629   current_file_size = 0;
16630   return ret;
16631 }
16632
16633 #ifdef SUPPORT_DISASSEMBLY
16634 /* Needed by the i386 disassembler.  For extra credit, someone could
16635    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16636    symbols.  */
16637
16638 void
16639 print_address (unsigned int addr, FILE * outfile)
16640 {
16641   fprintf (outfile,"0x%8.8x", addr);
16642 }
16643
16644 /* Needed by the i386 disassembler.  */
16645 void
16646 db_task_printsym (unsigned int addr)
16647 {
16648   print_address (addr, stderr);
16649 }
16650 #endif
16651
16652 int
16653 main (int argc, char ** argv)
16654 {
16655   int err;
16656
16657 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16658   setlocale (LC_MESSAGES, "");
16659 #endif
16660 #if defined (HAVE_SETLOCALE)
16661   setlocale (LC_CTYPE, "");
16662 #endif
16663   bindtextdomain (PACKAGE, LOCALEDIR);
16664   textdomain (PACKAGE);
16665
16666   expandargv (&argc, &argv);
16667
16668   parse_args (argc, argv);
16669
16670   if (num_dump_sects > 0)
16671     {
16672       /* Make a copy of the dump_sects array.  */
16673       cmdline_dump_sects = (dump_type *)
16674           malloc (num_dump_sects * sizeof (* dump_sects));
16675       if (cmdline_dump_sects == NULL)
16676         error (_("Out of memory allocating dump request table.\n"));
16677       else
16678         {
16679           memcpy (cmdline_dump_sects, dump_sects,
16680                   num_dump_sects * sizeof (* dump_sects));
16681           num_cmdline_dump_sects = num_dump_sects;
16682         }
16683     }
16684
16685   if (optind < (argc - 1))
16686     show_name = 1;
16687   else if (optind >= argc)
16688     {
16689       warn (_("Nothing to do.\n"));
16690       usage (stderr);
16691     }
16692
16693   err = 0;
16694   while (optind < argc)
16695     err |= process_file (argv[optind++]);
16696
16697   if (dump_sects != NULL)
16698     free (dump_sects);
16699   if (cmdline_dump_sects != NULL)
16700     free (cmdline_dump_sects);
16701
16702   return err;
16703 }