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               break;
4000             default:
4001               result = NULL;
4002               break;
4003             }
4004
4005           if (result != NULL)
4006             return result;
4007
4008           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4009         }
4010       else
4011         /* This message is probably going to be displayed in a 15
4012            character wide field, so put the hex value first.  */
4013         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4014
4015       return buff;
4016     }
4017 }
4018
4019 #define OPTION_DEBUG_DUMP       512
4020 #define OPTION_DYN_SYMS         513
4021 #define OPTION_DWARF_DEPTH      514
4022 #define OPTION_DWARF_START      515
4023 #define OPTION_DWARF_CHECK      516
4024
4025 static struct option options[] =
4026 {
4027   {"all",              no_argument, 0, 'a'},
4028   {"file-header",      no_argument, 0, 'h'},
4029   {"program-headers",  no_argument, 0, 'l'},
4030   {"headers",          no_argument, 0, 'e'},
4031   {"histogram",        no_argument, 0, 'I'},
4032   {"segments",         no_argument, 0, 'l'},
4033   {"sections",         no_argument, 0, 'S'},
4034   {"section-headers",  no_argument, 0, 'S'},
4035   {"section-groups",   no_argument, 0, 'g'},
4036   {"section-details",  no_argument, 0, 't'},
4037   {"full-section-name",no_argument, 0, 'N'},
4038   {"symbols",          no_argument, 0, 's'},
4039   {"syms",             no_argument, 0, 's'},
4040   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4041   {"relocs",           no_argument, 0, 'r'},
4042   {"notes",            no_argument, 0, 'n'},
4043   {"dynamic",          no_argument, 0, 'd'},
4044   {"arch-specific",    no_argument, 0, 'A'},
4045   {"version-info",     no_argument, 0, 'V'},
4046   {"use-dynamic",      no_argument, 0, 'D'},
4047   {"unwind",           no_argument, 0, 'u'},
4048   {"archive-index",    no_argument, 0, 'c'},
4049   {"hex-dump",         required_argument, 0, 'x'},
4050   {"relocated-dump",   required_argument, 0, 'R'},
4051   {"string-dump",      required_argument, 0, 'p'},
4052   {"decompress",       no_argument, 0, 'z'},
4053 #ifdef SUPPORT_DISASSEMBLY
4054   {"instruction-dump", required_argument, 0, 'i'},
4055 #endif
4056   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4057
4058   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4059   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4060   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4061
4062   {"version",          no_argument, 0, 'v'},
4063   {"wide",             no_argument, 0, 'W'},
4064   {"help",             no_argument, 0, 'H'},
4065   {0,                  no_argument, 0, 0}
4066 };
4067
4068 static void
4069 usage (FILE * stream)
4070 {
4071   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4072   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4073   fprintf (stream, _(" Options are:\n\
4074   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4075   -h --file-header       Display the ELF file header\n\
4076   -l --program-headers   Display the program headers\n\
4077      --segments          An alias for --program-headers\n\
4078   -S --section-headers   Display the sections' header\n\
4079      --sections          An alias for --section-headers\n\
4080   -g --section-groups    Display the section groups\n\
4081   -t --section-details   Display the section details\n\
4082   -e --headers           Equivalent to: -h -l -S\n\
4083   -s --syms              Display the symbol table\n\
4084      --symbols           An alias for --syms\n\
4085   --dyn-syms             Display the dynamic symbol table\n\
4086   -n --notes             Display the core notes (if present)\n\
4087   -r --relocs            Display the relocations (if present)\n\
4088   -u --unwind            Display the unwind info (if present)\n\
4089   -d --dynamic           Display the dynamic section (if present)\n\
4090   -V --version-info      Display the version sections (if present)\n\
4091   -A --arch-specific     Display architecture specific information (if any)\n\
4092   -c --archive-index     Display the symbol/file index in an archive\n\
4093   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4094   -x --hex-dump=<number|name>\n\
4095                          Dump the contents of section <number|name> as bytes\n\
4096   -p --string-dump=<number|name>\n\
4097                          Dump the contents of section <number|name> as strings\n\
4098   -R --relocated-dump=<number|name>\n\
4099                          Dump the contents of section <number|name> as relocated bytes\n\
4100   -z --decompress        Decompress section before dumping it\n\
4101   -w[lLiaprmfFsoRt] or\n\
4102   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4103                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4104                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4105                =addr,=cu_index]\n\
4106                          Display the contents of DWARF2 debug sections\n"));
4107   fprintf (stream, _("\
4108   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4109   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4110                          or deeper\n"));
4111 #ifdef SUPPORT_DISASSEMBLY
4112   fprintf (stream, _("\
4113   -i --instruction-dump=<number|name>\n\
4114                          Disassemble the contents of section <number|name>\n"));
4115 #endif
4116   fprintf (stream, _("\
4117   -I --histogram         Display histogram of bucket list lengths\n\
4118   -W --wide              Allow output width to exceed 80 characters\n\
4119   @<file>                Read options from <file>\n\
4120   -H --help              Display this information\n\
4121   -v --version           Display the version number of readelf\n"));
4122
4123   if (REPORT_BUGS_TO[0] && stream == stdout)
4124     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4125
4126   exit (stream == stdout ? 0 : 1);
4127 }
4128
4129 /* Record the fact that the user wants the contents of section number
4130    SECTION to be displayed using the method(s) encoded as flags bits
4131    in TYPE.  Note, TYPE can be zero if we are creating the array for
4132    the first time.  */
4133
4134 static void
4135 request_dump_bynumber (unsigned int section, dump_type type)
4136 {
4137   if (section >= num_dump_sects)
4138     {
4139       dump_type * new_dump_sects;
4140
4141       new_dump_sects = (dump_type *) calloc (section + 1,
4142                                              sizeof (* dump_sects));
4143
4144       if (new_dump_sects == NULL)
4145         error (_("Out of memory allocating dump request table.\n"));
4146       else
4147         {
4148           /* Copy current flag settings.  */
4149           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4150
4151           free (dump_sects);
4152
4153           dump_sects = new_dump_sects;
4154           num_dump_sects = section + 1;
4155         }
4156     }
4157
4158   if (dump_sects)
4159     dump_sects[section] |= type;
4160
4161   return;
4162 }
4163
4164 /* Request a dump by section name.  */
4165
4166 static void
4167 request_dump_byname (const char * section, dump_type type)
4168 {
4169   struct dump_list_entry * new_request;
4170
4171   new_request = (struct dump_list_entry *)
4172       malloc (sizeof (struct dump_list_entry));
4173   if (!new_request)
4174     error (_("Out of memory allocating dump request table.\n"));
4175
4176   new_request->name = strdup (section);
4177   if (!new_request->name)
4178     error (_("Out of memory allocating dump request table.\n"));
4179
4180   new_request->type = type;
4181
4182   new_request->next = dump_sects_byname;
4183   dump_sects_byname = new_request;
4184 }
4185
4186 static inline void
4187 request_dump (dump_type type)
4188 {
4189   int section;
4190   char * cp;
4191
4192   do_dump++;
4193   section = strtoul (optarg, & cp, 0);
4194
4195   if (! *cp && section >= 0)
4196     request_dump_bynumber (section, type);
4197   else
4198     request_dump_byname (optarg, type);
4199 }
4200
4201
4202 static void
4203 parse_args (int argc, char ** argv)
4204 {
4205   int c;
4206
4207   if (argc < 2)
4208     usage (stderr);
4209
4210   while ((c = getopt_long
4211           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4212     {
4213       switch (c)
4214         {
4215         case 0:
4216           /* Long options.  */
4217           break;
4218         case 'H':
4219           usage (stdout);
4220           break;
4221
4222         case 'a':
4223           do_syms++;
4224           do_reloc++;
4225           do_unwind++;
4226           do_dynamic++;
4227           do_header++;
4228           do_sections++;
4229           do_section_groups++;
4230           do_segments++;
4231           do_version++;
4232           do_histogram++;
4233           do_arch++;
4234           do_notes++;
4235           break;
4236         case 'g':
4237           do_section_groups++;
4238           break;
4239         case 't':
4240         case 'N':
4241           do_sections++;
4242           do_section_details++;
4243           break;
4244         case 'e':
4245           do_header++;
4246           do_sections++;
4247           do_segments++;
4248           break;
4249         case 'A':
4250           do_arch++;
4251           break;
4252         case 'D':
4253           do_using_dynamic++;
4254           break;
4255         case 'r':
4256           do_reloc++;
4257           break;
4258         case 'u':
4259           do_unwind++;
4260           break;
4261         case 'h':
4262           do_header++;
4263           break;
4264         case 'l':
4265           do_segments++;
4266           break;
4267         case 's':
4268           do_syms++;
4269           break;
4270         case 'S':
4271           do_sections++;
4272           break;
4273         case 'd':
4274           do_dynamic++;
4275           break;
4276         case 'I':
4277           do_histogram++;
4278           break;
4279         case 'n':
4280           do_notes++;
4281           break;
4282         case 'c':
4283           do_archive_index++;
4284           break;
4285         case 'x':
4286           request_dump (HEX_DUMP);
4287           break;
4288         case 'p':
4289           request_dump (STRING_DUMP);
4290           break;
4291         case 'R':
4292           request_dump (RELOC_DUMP);
4293           break;
4294         case 'z':
4295           decompress_dumps++;
4296           break;
4297         case 'w':
4298           do_dump++;
4299           if (optarg == 0)
4300             {
4301               do_debugging = 1;
4302               dwarf_select_sections_all ();
4303             }
4304           else
4305             {
4306               do_debugging = 0;
4307               dwarf_select_sections_by_letters (optarg);
4308             }
4309           break;
4310         case OPTION_DEBUG_DUMP:
4311           do_dump++;
4312           if (optarg == 0)
4313             do_debugging = 1;
4314           else
4315             {
4316               do_debugging = 0;
4317               dwarf_select_sections_by_names (optarg);
4318             }
4319           break;
4320         case OPTION_DWARF_DEPTH:
4321           {
4322             char *cp;
4323
4324             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4325           }
4326           break;
4327         case OPTION_DWARF_START:
4328           {
4329             char *cp;
4330
4331             dwarf_start_die = strtoul (optarg, & cp, 0);
4332           }
4333           break;
4334         case OPTION_DWARF_CHECK:
4335           dwarf_check = 1;
4336           break;
4337         case OPTION_DYN_SYMS:
4338           do_dyn_syms++;
4339           break;
4340 #ifdef SUPPORT_DISASSEMBLY
4341         case 'i':
4342           request_dump (DISASS_DUMP);
4343           break;
4344 #endif
4345         case 'v':
4346           print_version (program_name);
4347           break;
4348         case 'V':
4349           do_version++;
4350           break;
4351         case 'W':
4352           do_wide++;
4353           break;
4354         default:
4355           /* xgettext:c-format */
4356           error (_("Invalid option '-%c'\n"), c);
4357           /* Drop through.  */
4358         case '?':
4359           usage (stderr);
4360         }
4361     }
4362
4363   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4364       && !do_segments && !do_header && !do_dump && !do_version
4365       && !do_histogram && !do_debugging && !do_arch && !do_notes
4366       && !do_section_groups && !do_archive_index
4367       && !do_dyn_syms)
4368     usage (stderr);
4369 }
4370
4371 static const char *
4372 get_elf_class (unsigned int elf_class)
4373 {
4374   static char buff[32];
4375
4376   switch (elf_class)
4377     {
4378     case ELFCLASSNONE: return _("none");
4379     case ELFCLASS32:   return "ELF32";
4380     case ELFCLASS64:   return "ELF64";
4381     default:
4382       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4383       return buff;
4384     }
4385 }
4386
4387 static const char *
4388 get_data_encoding (unsigned int encoding)
4389 {
4390   static char buff[32];
4391
4392   switch (encoding)
4393     {
4394     case ELFDATANONE: return _("none");
4395     case ELFDATA2LSB: return _("2's complement, little endian");
4396     case ELFDATA2MSB: return _("2's complement, big endian");
4397     default:
4398       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4399       return buff;
4400     }
4401 }
4402
4403 /* Decode the data held in 'elf_header'.  */
4404
4405 static int
4406 process_file_header (void)
4407 {
4408   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4409       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4410       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4411       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4412     {
4413       error
4414         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4415       return 0;
4416     }
4417
4418   init_dwarf_regnames (elf_header.e_machine);
4419
4420   if (do_header)
4421     {
4422       int i;
4423
4424       printf (_("ELF Header:\n"));
4425       printf (_("  Magic:   "));
4426       for (i = 0; i < EI_NIDENT; i++)
4427         printf ("%2.2x ", elf_header.e_ident[i]);
4428       printf ("\n");
4429       printf (_("  Class:                             %s\n"),
4430               get_elf_class (elf_header.e_ident[EI_CLASS]));
4431       printf (_("  Data:                              %s\n"),
4432               get_data_encoding (elf_header.e_ident[EI_DATA]));
4433       printf (_("  Version:                           %d %s\n"),
4434               elf_header.e_ident[EI_VERSION],
4435               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4436                ? "(current)"
4437                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4438                   ? _("<unknown: %lx>")
4439                   : "")));
4440       printf (_("  OS/ABI:                            %s\n"),
4441               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4442       printf (_("  ABI Version:                       %d\n"),
4443               elf_header.e_ident[EI_ABIVERSION]);
4444       printf (_("  Type:                              %s\n"),
4445               get_file_type (elf_header.e_type));
4446       printf (_("  Machine:                           %s\n"),
4447               get_machine_name (elf_header.e_machine));
4448       printf (_("  Version:                           0x%lx\n"),
4449               (unsigned long) elf_header.e_version);
4450
4451       printf (_("  Entry point address:               "));
4452       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4453       printf (_("\n  Start of program headers:          "));
4454       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4455       printf (_(" (bytes into file)\n  Start of section headers:          "));
4456       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4457       printf (_(" (bytes into file)\n"));
4458
4459       printf (_("  Flags:                             0x%lx%s\n"),
4460               (unsigned long) elf_header.e_flags,
4461               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4462       printf (_("  Size of this header:               %ld (bytes)\n"),
4463               (long) elf_header.e_ehsize);
4464       printf (_("  Size of program headers:           %ld (bytes)\n"),
4465               (long) elf_header.e_phentsize);
4466       printf (_("  Number of program headers:         %ld"),
4467               (long) elf_header.e_phnum);
4468       if (section_headers != NULL
4469           && elf_header.e_phnum == PN_XNUM
4470           && section_headers[0].sh_info != 0)
4471         printf (" (%ld)", (long) section_headers[0].sh_info);
4472       putc ('\n', stdout);
4473       printf (_("  Size of section headers:           %ld (bytes)\n"),
4474               (long) elf_header.e_shentsize);
4475       printf (_("  Number of section headers:         %ld"),
4476               (long) elf_header.e_shnum);
4477       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4478         printf (" (%ld)", (long) section_headers[0].sh_size);
4479       putc ('\n', stdout);
4480       printf (_("  Section header string table index: %ld"),
4481               (long) elf_header.e_shstrndx);
4482       if (section_headers != NULL
4483           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4484         printf (" (%u)", section_headers[0].sh_link);
4485       else if (elf_header.e_shstrndx != SHN_UNDEF
4486                && elf_header.e_shstrndx >= elf_header.e_shnum)
4487         printf (_(" <corrupt: out of range>"));
4488       putc ('\n', stdout);
4489     }
4490
4491   if (section_headers != NULL)
4492     {
4493       if (elf_header.e_phnum == PN_XNUM
4494           && section_headers[0].sh_info != 0)
4495         elf_header.e_phnum = section_headers[0].sh_info;
4496       if (elf_header.e_shnum == SHN_UNDEF)
4497         elf_header.e_shnum = section_headers[0].sh_size;
4498       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4499         elf_header.e_shstrndx = section_headers[0].sh_link;
4500       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4501         elf_header.e_shstrndx = SHN_UNDEF;
4502       free (section_headers);
4503       section_headers = NULL;
4504     }
4505
4506   return 1;
4507 }
4508
4509 static bfd_boolean
4510 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4511 {
4512   Elf32_External_Phdr * phdrs;
4513   Elf32_External_Phdr * external;
4514   Elf_Internal_Phdr *   internal;
4515   unsigned int i;
4516   unsigned int size = elf_header.e_phentsize;
4517   unsigned int num  = elf_header.e_phnum;
4518
4519   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4520   if (size == 0 || num == 0)
4521     return FALSE;
4522   if (size < sizeof * phdrs)
4523     {
4524       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4525       return FALSE;
4526     }
4527   if (size > sizeof * phdrs)
4528     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4529
4530   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4531                                             size, num, _("program headers"));
4532   if (phdrs == NULL)
4533     return FALSE;
4534
4535   for (i = 0, internal = pheaders, external = phdrs;
4536        i < elf_header.e_phnum;
4537        i++, internal++, external++)
4538     {
4539       internal->p_type   = BYTE_GET (external->p_type);
4540       internal->p_offset = BYTE_GET (external->p_offset);
4541       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4542       internal->p_paddr  = BYTE_GET (external->p_paddr);
4543       internal->p_filesz = BYTE_GET (external->p_filesz);
4544       internal->p_memsz  = BYTE_GET (external->p_memsz);
4545       internal->p_flags  = BYTE_GET (external->p_flags);
4546       internal->p_align  = BYTE_GET (external->p_align);
4547     }
4548
4549   free (phdrs);
4550   return TRUE;
4551 }
4552
4553 static bfd_boolean
4554 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4555 {
4556   Elf64_External_Phdr * phdrs;
4557   Elf64_External_Phdr * external;
4558   Elf_Internal_Phdr *   internal;
4559   unsigned int i;
4560   unsigned int size = elf_header.e_phentsize;
4561   unsigned int num  = elf_header.e_phnum;
4562
4563   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4564   if (size == 0 || num == 0)
4565     return FALSE;
4566   if (size < sizeof * phdrs)
4567     {
4568       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4569       return FALSE;
4570     }
4571   if (size > sizeof * phdrs)
4572     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4573
4574   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4575                                             size, num, _("program headers"));
4576   if (!phdrs)
4577     return FALSE;
4578
4579   for (i = 0, internal = pheaders, external = phdrs;
4580        i < elf_header.e_phnum;
4581        i++, internal++, external++)
4582     {
4583       internal->p_type   = BYTE_GET (external->p_type);
4584       internal->p_flags  = BYTE_GET (external->p_flags);
4585       internal->p_offset = BYTE_GET (external->p_offset);
4586       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4587       internal->p_paddr  = BYTE_GET (external->p_paddr);
4588       internal->p_filesz = BYTE_GET (external->p_filesz);
4589       internal->p_memsz  = BYTE_GET (external->p_memsz);
4590       internal->p_align  = BYTE_GET (external->p_align);
4591     }
4592
4593   free (phdrs);
4594   return TRUE;
4595 }
4596
4597 /* Returns 1 if the program headers were read into `program_headers'.  */
4598
4599 static int
4600 get_program_headers (FILE * file)
4601 {
4602   Elf_Internal_Phdr * phdrs;
4603
4604   /* Check cache of prior read.  */
4605   if (program_headers != NULL)
4606     return 1;
4607
4608   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4609                                          sizeof (Elf_Internal_Phdr));
4610
4611   if (phdrs == NULL)
4612     {
4613       error (_("Out of memory reading %u program headers\n"),
4614              elf_header.e_phnum);
4615       return 0;
4616     }
4617
4618   if (is_32bit_elf
4619       ? get_32bit_program_headers (file, phdrs)
4620       : get_64bit_program_headers (file, phdrs))
4621     {
4622       program_headers = phdrs;
4623       return 1;
4624     }
4625
4626   free (phdrs);
4627   return 0;
4628 }
4629
4630 /* Returns 1 if the program headers were loaded.  */
4631
4632 static int
4633 process_program_headers (FILE * file)
4634 {
4635   Elf_Internal_Phdr * segment;
4636   unsigned int i;
4637
4638   if (elf_header.e_phnum == 0)
4639     {
4640       /* PR binutils/12467.  */
4641       if (elf_header.e_phoff != 0)
4642         warn (_("possibly corrupt ELF header - it has a non-zero program"
4643                 " header offset, but no program headers\n"));
4644       else if (do_segments)
4645         printf (_("\nThere are no program headers in this file.\n"));
4646       return 0;
4647     }
4648
4649   if (do_segments && !do_header)
4650     {
4651       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4652       printf (_("Entry point "));
4653       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4654       printf (_("\nThere are %d program headers, starting at offset "),
4655               elf_header.e_phnum);
4656       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4657       printf ("\n");
4658     }
4659
4660   if (! get_program_headers (file))
4661       return 0;
4662
4663   if (do_segments)
4664     {
4665       if (elf_header.e_phnum > 1)
4666         printf (_("\nProgram Headers:\n"));
4667       else
4668         printf (_("\nProgram Headers:\n"));
4669
4670       if (is_32bit_elf)
4671         printf
4672           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4673       else if (do_wide)
4674         printf
4675           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4676       else
4677         {
4678           printf
4679             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4680           printf
4681             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4682         }
4683     }
4684
4685   dynamic_addr = 0;
4686   dynamic_size = 0;
4687
4688   for (i = 0, segment = program_headers;
4689        i < elf_header.e_phnum;
4690        i++, segment++)
4691     {
4692       if (do_segments)
4693         {
4694           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4695
4696           if (is_32bit_elf)
4697             {
4698               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4699               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4700               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4701               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4702               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4703               printf ("%c%c%c ",
4704                       (segment->p_flags & PF_R ? 'R' : ' '),
4705                       (segment->p_flags & PF_W ? 'W' : ' '),
4706                       (segment->p_flags & PF_X ? 'E' : ' '));
4707               printf ("%#lx", (unsigned long) segment->p_align);
4708             }
4709           else if (do_wide)
4710             {
4711               if ((unsigned long) segment->p_offset == segment->p_offset)
4712                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4713               else
4714                 {
4715                   print_vma (segment->p_offset, FULL_HEX);
4716                   putchar (' ');
4717                 }
4718
4719               print_vma (segment->p_vaddr, FULL_HEX);
4720               putchar (' ');
4721               print_vma (segment->p_paddr, FULL_HEX);
4722               putchar (' ');
4723
4724               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4725                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4726               else
4727                 {
4728                   print_vma (segment->p_filesz, FULL_HEX);
4729                   putchar (' ');
4730                 }
4731
4732               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4733                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4734               else
4735                 {
4736                   print_vma (segment->p_memsz, FULL_HEX);
4737                 }
4738
4739               printf (" %c%c%c ",
4740                       (segment->p_flags & PF_R ? 'R' : ' '),
4741                       (segment->p_flags & PF_W ? 'W' : ' '),
4742                       (segment->p_flags & PF_X ? 'E' : ' '));
4743
4744               if ((unsigned long) segment->p_align == segment->p_align)
4745                 printf ("%#lx", (unsigned long) segment->p_align);
4746               else
4747                 {
4748                   print_vma (segment->p_align, PREFIX_HEX);
4749                 }
4750             }
4751           else
4752             {
4753               print_vma (segment->p_offset, FULL_HEX);
4754               putchar (' ');
4755               print_vma (segment->p_vaddr, FULL_HEX);
4756               putchar (' ');
4757               print_vma (segment->p_paddr, FULL_HEX);
4758               printf ("\n                 ");
4759               print_vma (segment->p_filesz, FULL_HEX);
4760               putchar (' ');
4761               print_vma (segment->p_memsz, FULL_HEX);
4762               printf ("  %c%c%c    ",
4763                       (segment->p_flags & PF_R ? 'R' : ' '),
4764                       (segment->p_flags & PF_W ? 'W' : ' '),
4765                       (segment->p_flags & PF_X ? 'E' : ' '));
4766               print_vma (segment->p_align, HEX);
4767             }
4768         }
4769
4770       if (do_segments)
4771         putc ('\n', stdout);
4772
4773       switch (segment->p_type)
4774         {
4775         case PT_DYNAMIC:
4776           if (dynamic_addr)
4777             error (_("more than one dynamic segment\n"));
4778
4779           /* By default, assume that the .dynamic section is the first
4780              section in the DYNAMIC segment.  */
4781           dynamic_addr = segment->p_offset;
4782           dynamic_size = segment->p_filesz;
4783           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4784           if (dynamic_addr + dynamic_size >= current_file_size)
4785             {
4786               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4787               dynamic_addr = dynamic_size = 0;
4788             }
4789
4790           /* Try to locate the .dynamic section. If there is
4791              a section header table, we can easily locate it.  */
4792           if (section_headers != NULL)
4793             {
4794               Elf_Internal_Shdr * sec;
4795
4796               sec = find_section (".dynamic");
4797               if (sec == NULL || sec->sh_size == 0)
4798                 {
4799                   /* A corresponding .dynamic section is expected, but on
4800                      IA-64/OpenVMS it is OK for it to be missing.  */
4801                   if (!is_ia64_vms ())
4802                     error (_("no .dynamic section in the dynamic segment\n"));
4803                   break;
4804                 }
4805
4806               if (sec->sh_type == SHT_NOBITS)
4807                 {
4808                   dynamic_size = 0;
4809                   break;
4810                 }
4811
4812               dynamic_addr = sec->sh_offset;
4813               dynamic_size = sec->sh_size;
4814
4815               if (dynamic_addr < segment->p_offset
4816                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4817                 warn (_("the .dynamic section is not contained"
4818                         " within the dynamic segment\n"));
4819               else if (dynamic_addr > segment->p_offset)
4820                 warn (_("the .dynamic section is not the first section"
4821                         " in the dynamic segment.\n"));
4822             }
4823           break;
4824
4825         case PT_INTERP:
4826           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4827                      SEEK_SET))
4828             error (_("Unable to find program interpreter name\n"));
4829           else
4830             {
4831               char fmt [32];
4832               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4833
4834               if (ret >= (int) sizeof (fmt) || ret < 0)
4835                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4836
4837               program_interpreter[0] = 0;
4838               if (fscanf (file, fmt, program_interpreter) <= 0)
4839                 error (_("Unable to read program interpreter name\n"));
4840
4841               if (do_segments)
4842                 printf (_("      [Requesting program interpreter: %s]\n"),
4843                     program_interpreter);
4844             }
4845           break;
4846         }
4847     }
4848
4849   if (do_segments && section_headers != NULL && string_table != NULL)
4850     {
4851       printf (_("\n Section to Segment mapping:\n"));
4852       printf (_("  Segment Sections...\n"));
4853
4854       for (i = 0; i < elf_header.e_phnum; i++)
4855         {
4856           unsigned int j;
4857           Elf_Internal_Shdr * section;
4858
4859           segment = program_headers + i;
4860           section = section_headers + 1;
4861
4862           printf ("   %2.2d     ", i);
4863
4864           for (j = 1; j < elf_header.e_shnum; j++, section++)
4865             {
4866               if (!ELF_TBSS_SPECIAL (section, segment)
4867                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4868                 printf ("%s ", printable_section_name (section));
4869             }
4870
4871           putc ('\n',stdout);
4872         }
4873     }
4874
4875   return 1;
4876 }
4877
4878
4879 /* Find the file offset corresponding to VMA by using the program headers.  */
4880
4881 static long
4882 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4883 {
4884   Elf_Internal_Phdr * seg;
4885
4886   if (! get_program_headers (file))
4887     {
4888       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4889       return (long) vma;
4890     }
4891
4892   for (seg = program_headers;
4893        seg < program_headers + elf_header.e_phnum;
4894        ++seg)
4895     {
4896       if (seg->p_type != PT_LOAD)
4897         continue;
4898
4899       if (vma >= (seg->p_vaddr & -seg->p_align)
4900           && vma + size <= seg->p_vaddr + seg->p_filesz)
4901         return vma - seg->p_vaddr + seg->p_offset;
4902     }
4903
4904   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4905         (unsigned long) vma);
4906   return (long) vma;
4907 }
4908
4909
4910 /* Allocate memory and load the sections headers into the global pointer
4911    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4912    generate any error messages if the load fails.  */
4913
4914 static bfd_boolean
4915 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4916 {
4917   Elf32_External_Shdr * shdrs;
4918   Elf_Internal_Shdr *   internal;
4919   unsigned int i;
4920   unsigned int size = elf_header.e_shentsize;
4921   unsigned int num = probe ? 1 : elf_header.e_shnum;
4922
4923   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4924   if (size == 0 || num == 0)
4925     return FALSE;
4926   if (size < sizeof * shdrs)
4927     {
4928       if (! probe)
4929         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4930       return FALSE;
4931     }
4932   if (!probe && size > sizeof * shdrs)
4933     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4934
4935   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4936                                             size, num,
4937                                             probe ? NULL : _("section headers"));
4938   if (shdrs == NULL)
4939     return FALSE;
4940
4941   if (section_headers != NULL)
4942     free (section_headers);
4943   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4944                                                    sizeof (Elf_Internal_Shdr));
4945   if (section_headers == NULL)
4946     {
4947       if (!probe)
4948         error (_("Out of memory reading %u section headers\n"), num);
4949       return FALSE;
4950     }
4951
4952   for (i = 0, internal = section_headers;
4953        i < num;
4954        i++, internal++)
4955     {
4956       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4957       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4958       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4959       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4960       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4961       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4962       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4963       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4964       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4965       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4966     }
4967
4968   free (shdrs);
4969   return TRUE;
4970 }
4971
4972 static bfd_boolean
4973 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4974 {
4975   Elf64_External_Shdr * shdrs;
4976   Elf_Internal_Shdr *   internal;
4977   unsigned int i;
4978   unsigned int size = elf_header.e_shentsize;
4979   unsigned int num = probe ? 1 : elf_header.e_shnum;
4980
4981   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4982   if (size == 0 || num == 0)
4983     return FALSE;
4984   if (size < sizeof * shdrs)
4985     {
4986       if (! probe)
4987         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4988       return FALSE;
4989     }
4990   if (! probe && size > sizeof * shdrs)
4991     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4992
4993   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4994                                             size, num,
4995                                             probe ? NULL : _("section headers"));
4996   if (shdrs == NULL)
4997     return FALSE;
4998
4999   if (section_headers != NULL)
5000     free (section_headers);
5001   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5002                                                    sizeof (Elf_Internal_Shdr));
5003   if (section_headers == NULL)
5004     {
5005       if (! probe)
5006         error (_("Out of memory reading %u section headers\n"), num);
5007       return FALSE;
5008     }
5009
5010   for (i = 0, internal = section_headers;
5011        i < num;
5012        i++, internal++)
5013     {
5014       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5015       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5016       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5017       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5018       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5019       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5020       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5021       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5022       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5023       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5024     }
5025
5026   free (shdrs);
5027   return TRUE;
5028 }
5029
5030 static Elf_Internal_Sym *
5031 get_32bit_elf_symbols (FILE * file,
5032                        Elf_Internal_Shdr * section,
5033                        unsigned long * num_syms_return)
5034 {
5035   unsigned long number = 0;
5036   Elf32_External_Sym * esyms = NULL;
5037   Elf_External_Sym_Shndx * shndx = NULL;
5038   Elf_Internal_Sym * isyms = NULL;
5039   Elf_Internal_Sym * psym;
5040   unsigned int j;
5041
5042   if (section->sh_size == 0)
5043     {
5044       if (num_syms_return != NULL)
5045         * num_syms_return = 0;
5046       return NULL;
5047     }
5048
5049   /* Run some sanity checks first.  */
5050   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5051     {
5052       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5053              printable_section_name (section), (unsigned long) section->sh_entsize);
5054       goto exit_point;
5055     }
5056
5057   if (section->sh_size > current_file_size)
5058     {
5059       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5060              printable_section_name (section), (unsigned long) section->sh_size);
5061       goto exit_point;
5062     }
5063
5064   number = section->sh_size / section->sh_entsize;
5065
5066   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5067     {
5068       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5069              (unsigned long) section->sh_size,
5070              printable_section_name (section),
5071              (unsigned long) section->sh_entsize);
5072       goto exit_point;
5073     }
5074
5075   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5076                                            section->sh_size, _("symbols"));
5077   if (esyms == NULL)
5078     goto exit_point;
5079
5080   {
5081     elf_section_list * entry;
5082
5083     shndx = NULL;
5084     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5085       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5086         {
5087           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5088                                                        entry->hdr->sh_offset,
5089                                                        1, entry->hdr->sh_size,
5090                                                        _("symbol table section indicies"));
5091           if (shndx == NULL)
5092             goto exit_point;
5093           /* PR17531: file: heap-buffer-overflow */
5094           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5095             {
5096               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5097                      printable_section_name (entry->hdr),
5098                      (unsigned long) entry->hdr->sh_size,
5099                      (unsigned long) section->sh_size);
5100               goto exit_point;
5101             }
5102         }
5103   }
5104
5105   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5106
5107   if (isyms == NULL)
5108     {
5109       error (_("Out of memory reading %lu symbols\n"),
5110              (unsigned long) number);
5111       goto exit_point;
5112     }
5113
5114   for (j = 0, psym = isyms; j < number; j++, psym++)
5115     {
5116       psym->st_name  = BYTE_GET (esyms[j].st_name);
5117       psym->st_value = BYTE_GET (esyms[j].st_value);
5118       psym->st_size  = BYTE_GET (esyms[j].st_size);
5119       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5120       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5121         psym->st_shndx
5122           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5123       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5124         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5125       psym->st_info  = BYTE_GET (esyms[j].st_info);
5126       psym->st_other = BYTE_GET (esyms[j].st_other);
5127     }
5128
5129  exit_point:
5130   if (shndx != NULL)
5131     free (shndx);
5132   if (esyms != NULL)
5133     free (esyms);
5134
5135   if (num_syms_return != NULL)
5136     * num_syms_return = isyms == NULL ? 0 : number;
5137
5138   return isyms;
5139 }
5140
5141 static Elf_Internal_Sym *
5142 get_64bit_elf_symbols (FILE * file,
5143                        Elf_Internal_Shdr * section,
5144                        unsigned long * num_syms_return)
5145 {
5146   unsigned long number = 0;
5147   Elf64_External_Sym * esyms = NULL;
5148   Elf_External_Sym_Shndx * shndx = NULL;
5149   Elf_Internal_Sym * isyms = NULL;
5150   Elf_Internal_Sym * psym;
5151   unsigned int j;
5152
5153   if (section->sh_size == 0)
5154     {
5155       if (num_syms_return != NULL)
5156         * num_syms_return = 0;
5157       return NULL;
5158     }
5159
5160   /* Run some sanity checks first.  */
5161   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5162     {
5163       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5164              printable_section_name (section),
5165              (unsigned long) section->sh_entsize);
5166       goto exit_point;
5167     }
5168
5169   if (section->sh_size > current_file_size)
5170     {
5171       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5172              printable_section_name (section),
5173              (unsigned long) section->sh_size);
5174       goto exit_point;
5175     }
5176
5177   number = section->sh_size / section->sh_entsize;
5178
5179   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5180     {
5181       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5182              (unsigned long) section->sh_size,
5183              printable_section_name (section),
5184              (unsigned long) section->sh_entsize);
5185       goto exit_point;
5186     }
5187
5188   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5189                                            section->sh_size, _("symbols"));
5190   if (!esyms)
5191     goto exit_point;
5192
5193   {
5194     elf_section_list * entry;
5195
5196     shndx = NULL;
5197     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5198       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5199         {
5200           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5201                                                        entry->hdr->sh_offset,
5202                                                        1, entry->hdr->sh_size,
5203                                                        _("symbol table section indicies"));
5204           if (shndx == NULL)
5205             goto exit_point;
5206           /* PR17531: file: heap-buffer-overflow */
5207           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5208             {
5209               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5210                      printable_section_name (entry->hdr),
5211                      (unsigned long) entry->hdr->sh_size,
5212                      (unsigned long) section->sh_size);
5213               goto exit_point;
5214             }
5215         }
5216   }
5217
5218   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5219
5220   if (isyms == NULL)
5221     {
5222       error (_("Out of memory reading %lu symbols\n"),
5223              (unsigned long) number);
5224       goto exit_point;
5225     }
5226
5227   for (j = 0, psym = isyms; j < number; j++, psym++)
5228     {
5229       psym->st_name  = BYTE_GET (esyms[j].st_name);
5230       psym->st_info  = BYTE_GET (esyms[j].st_info);
5231       psym->st_other = BYTE_GET (esyms[j].st_other);
5232       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5233
5234       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5235         psym->st_shndx
5236           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5237       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5238         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5239
5240       psym->st_value = BYTE_GET (esyms[j].st_value);
5241       psym->st_size  = BYTE_GET (esyms[j].st_size);
5242     }
5243
5244  exit_point:
5245   if (shndx != NULL)
5246     free (shndx);
5247   if (esyms != NULL)
5248     free (esyms);
5249
5250   if (num_syms_return != NULL)
5251     * num_syms_return = isyms == NULL ? 0 : number;
5252
5253   return isyms;
5254 }
5255
5256 static const char *
5257 get_elf_section_flags (bfd_vma sh_flags)
5258 {
5259   static char buff[1024];
5260   char * p = buff;
5261   int field_size = is_32bit_elf ? 8 : 16;
5262   int sindex;
5263   int size = sizeof (buff) - (field_size + 4 + 1);
5264   bfd_vma os_flags = 0;
5265   bfd_vma proc_flags = 0;
5266   bfd_vma unknown_flags = 0;
5267   static const struct
5268     {
5269       const char * str;
5270       int len;
5271     }
5272   flags [] =
5273     {
5274       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5275       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5276       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5277       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5278       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5279       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5280       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5281       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5282       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5283       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5284       /* IA-64 specific.  */
5285       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5286       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5287       /* IA-64 OpenVMS specific.  */
5288       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5289       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5290       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5291       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5292       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5293       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5294       /* Generic.  */
5295       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5296       /* SPARC specific.  */
5297       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5298       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5299       /* ARM specific.  */
5300       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5301       /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5302       /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5303     };
5304
5305   if (do_section_details)
5306     {
5307       sprintf (buff, "[%*.*lx]: ",
5308                field_size, field_size, (unsigned long) sh_flags);
5309       p += field_size + 4;
5310     }
5311
5312   while (sh_flags)
5313     {
5314       bfd_vma flag;
5315
5316       flag = sh_flags & - sh_flags;
5317       sh_flags &= ~ flag;
5318
5319       if (do_section_details)
5320         {
5321           switch (flag)
5322             {
5323             case SHF_WRITE:             sindex = 0; break;
5324             case SHF_ALLOC:             sindex = 1; break;
5325             case SHF_EXECINSTR:         sindex = 2; break;
5326             case SHF_MERGE:             sindex = 3; break;
5327             case SHF_STRINGS:           sindex = 4; break;
5328             case SHF_INFO_LINK:         sindex = 5; break;
5329             case SHF_LINK_ORDER:        sindex = 6; break;
5330             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5331             case SHF_GROUP:             sindex = 8; break;
5332             case SHF_TLS:               sindex = 9; break;
5333             case SHF_EXCLUDE:           sindex = 18; break;
5334             case SHF_COMPRESSED:        sindex = 20; break;
5335
5336             default:
5337               sindex = -1;
5338               switch (elf_header.e_machine)
5339                 {
5340                 case EM_IA_64:
5341                   if (flag == SHF_IA_64_SHORT)
5342                     sindex = 10;
5343                   else if (flag == SHF_IA_64_NORECOV)
5344                     sindex = 11;
5345 #ifdef BFD64
5346                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5347                     switch (flag)
5348                       {
5349                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5350                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5351                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5352                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5353                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5354                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5355                       default:                        break;
5356                       }
5357 #endif
5358                   break;
5359
5360                 case EM_386:
5361                 case EM_IAMCU:
5362                 case EM_X86_64:
5363                 case EM_L1OM:
5364                 case EM_K1OM:
5365                 case EM_OLD_SPARCV9:
5366                 case EM_SPARC32PLUS:
5367                 case EM_SPARCV9:
5368                 case EM_SPARC:
5369                   if (flag == SHF_ORDERED)
5370                     sindex = 19;
5371                   break;
5372
5373                 case EM_ARM:
5374                   switch (flag)
5375                     {
5376                     case SHF_ENTRYSECT: sindex = 21; break;
5377                     case SHF_ARM_NOREAD: sindex = 22; break;
5378                     case SHF_COMDEF: sindex = 23; break;
5379                     default: break;
5380                     }
5381                   break;
5382
5383                 default:
5384                   break;
5385                 }
5386             }
5387
5388           if (sindex != -1)
5389             {
5390               if (p != buff + field_size + 4)
5391                 {
5392                   if (size < (10 + 2))
5393                     {
5394                       warn (_("Internal error: not enough buffer room for section flag info"));
5395                       return _("<unknown>");
5396                     }
5397                   size -= 2;
5398                   *p++ = ',';
5399                   *p++ = ' ';
5400                 }
5401
5402               size -= flags [sindex].len;
5403               p = stpcpy (p, flags [sindex].str);
5404             }
5405           else if (flag & SHF_MASKOS)
5406             os_flags |= flag;
5407           else if (flag & SHF_MASKPROC)
5408             proc_flags |= flag;
5409           else
5410             unknown_flags |= flag;
5411         }
5412       else
5413         {
5414           switch (flag)
5415             {
5416             case SHF_WRITE:             *p = 'W'; break;
5417             case SHF_ALLOC:             *p = 'A'; break;
5418             case SHF_EXECINSTR:         *p = 'X'; break;
5419             case SHF_MERGE:             *p = 'M'; break;
5420             case SHF_STRINGS:           *p = 'S'; break;
5421             case SHF_INFO_LINK:         *p = 'I'; break;
5422             case SHF_LINK_ORDER:        *p = 'L'; break;
5423             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5424             case SHF_GROUP:             *p = 'G'; break;
5425             case SHF_TLS:               *p = 'T'; break;
5426             case SHF_EXCLUDE:           *p = 'E'; break;
5427             case SHF_COMPRESSED:        *p = 'C'; break;
5428
5429             default:
5430               if ((elf_header.e_machine == EM_X86_64
5431                    || elf_header.e_machine == EM_L1OM
5432                    || elf_header.e_machine == EM_K1OM)
5433                   && flag == SHF_X86_64_LARGE)
5434                 *p = 'l';
5435               else if (elf_header.e_machine == EM_ARM
5436                        && flag == SHF_ARM_NOREAD)
5437                   *p = 'y';
5438               else if (flag & SHF_MASKOS)
5439                 {
5440                   *p = 'o';
5441                   sh_flags &= ~ SHF_MASKOS;
5442                 }
5443               else if (flag & SHF_MASKPROC)
5444                 {
5445                   *p = 'p';
5446                   sh_flags &= ~ SHF_MASKPROC;
5447                 }
5448               else
5449                 *p = 'x';
5450               break;
5451             }
5452           p++;
5453         }
5454     }
5455
5456   if (do_section_details)
5457     {
5458       if (os_flags)
5459         {
5460           size -= 5 + field_size;
5461           if (p != buff + field_size + 4)
5462             {
5463               if (size < (2 + 1))
5464                 {
5465                   warn (_("Internal error: not enough buffer room for section flag info"));
5466                   return _("<unknown>");
5467                 }
5468               size -= 2;
5469               *p++ = ',';
5470               *p++ = ' ';
5471             }
5472           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5473                    (unsigned long) os_flags);
5474           p += 5 + field_size;
5475         }
5476       if (proc_flags)
5477         {
5478           size -= 7 + field_size;
5479           if (p != buff + field_size + 4)
5480             {
5481               if (size < (2 + 1))
5482                 {
5483                   warn (_("Internal error: not enough buffer room for section flag info"));
5484                   return _("<unknown>");
5485                 }
5486               size -= 2;
5487               *p++ = ',';
5488               *p++ = ' ';
5489             }
5490           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5491                    (unsigned long) proc_flags);
5492           p += 7 + field_size;
5493         }
5494       if (unknown_flags)
5495         {
5496           size -= 10 + field_size;
5497           if (p != buff + field_size + 4)
5498             {
5499               if (size < (2 + 1))
5500                 {
5501                   warn (_("Internal error: not enough buffer room for section flag info"));
5502                   return _("<unknown>");
5503                 }
5504               size -= 2;
5505               *p++ = ',';
5506               *p++ = ' ';
5507             }
5508           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5509                    (unsigned long) unknown_flags);
5510           p += 10 + field_size;
5511         }
5512     }
5513
5514   *p = '\0';
5515   return buff;
5516 }
5517
5518 static unsigned int
5519 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5520 {
5521   if (is_32bit_elf)
5522     {
5523       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5524       chdr->ch_type = BYTE_GET (echdr->ch_type);
5525       chdr->ch_size = BYTE_GET (echdr->ch_size);
5526       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5527       return sizeof (*echdr);
5528     }
5529   else
5530     {
5531       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5532       chdr->ch_type = BYTE_GET (echdr->ch_type);
5533       chdr->ch_size = BYTE_GET (echdr->ch_size);
5534       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5535       return sizeof (*echdr);
5536     }
5537 }
5538
5539 static int
5540 process_section_headers (FILE * file)
5541 {
5542   Elf_Internal_Shdr * section;
5543   unsigned int i;
5544
5545   section_headers = NULL;
5546
5547   if (elf_header.e_shnum == 0)
5548     {
5549       /* PR binutils/12467.  */
5550       if (elf_header.e_shoff != 0)
5551         warn (_("possibly corrupt ELF file header - it has a non-zero"
5552                 " section header offset, but no section headers\n"));
5553       else if (do_sections)
5554         printf (_("\nThere are no sections in this file.\n"));
5555
5556       return 1;
5557     }
5558
5559   if (do_sections && !do_header)
5560     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5561             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5562
5563   if (is_32bit_elf)
5564     {
5565       if (! get_32bit_section_headers (file, FALSE))
5566         return 0;
5567     }
5568   else if (! get_64bit_section_headers (file, FALSE))
5569     return 0;
5570
5571   /* Read in the string table, so that we have names to display.  */
5572   if (elf_header.e_shstrndx != SHN_UNDEF
5573        && elf_header.e_shstrndx < elf_header.e_shnum)
5574     {
5575       section = section_headers + elf_header.e_shstrndx;
5576
5577       if (section->sh_size != 0)
5578         {
5579           string_table = (char *) get_data (NULL, file, section->sh_offset,
5580                                             1, section->sh_size,
5581                                             _("string table"));
5582
5583           string_table_length = string_table != NULL ? section->sh_size : 0;
5584         }
5585     }
5586
5587   /* Scan the sections for the dynamic symbol table
5588      and dynamic string table and debug sections.  */
5589   dynamic_symbols = NULL;
5590   dynamic_strings = NULL;
5591   dynamic_syminfo = NULL;
5592   symtab_shndx_list = NULL;
5593
5594   eh_addr_size = is_32bit_elf ? 4 : 8;
5595   switch (elf_header.e_machine)
5596     {
5597     case EM_MIPS:
5598     case EM_MIPS_RS3_LE:
5599       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5600          FDE addresses.  However, the ABI also has a semi-official ILP32
5601          variant for which the normal FDE address size rules apply.
5602
5603          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5604          section, where XX is the size of longs in bits.  Unfortunately,
5605          earlier compilers provided no way of distinguishing ILP32 objects
5606          from LP64 objects, so if there's any doubt, we should assume that
5607          the official LP64 form is being used.  */
5608       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5609           && find_section (".gcc_compiled_long32") == NULL)
5610         eh_addr_size = 8;
5611       break;
5612
5613     case EM_H8_300:
5614     case EM_H8_300H:
5615       switch (elf_header.e_flags & EF_H8_MACH)
5616         {
5617         case E_H8_MACH_H8300:
5618         case E_H8_MACH_H8300HN:
5619         case E_H8_MACH_H8300SN:
5620         case E_H8_MACH_H8300SXN:
5621           eh_addr_size = 2;
5622           break;
5623         case E_H8_MACH_H8300H:
5624         case E_H8_MACH_H8300S:
5625         case E_H8_MACH_H8300SX:
5626           eh_addr_size = 4;
5627           break;
5628         }
5629       break;
5630
5631     case EM_M32C_OLD:
5632     case EM_M32C:
5633       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5634         {
5635         case EF_M32C_CPU_M16C:
5636           eh_addr_size = 2;
5637           break;
5638         }
5639       break;
5640     }
5641
5642 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5643   do                                                                    \
5644     {                                                                   \
5645       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5646       if (section->sh_entsize != expected_entsize)                      \
5647         {                                                               \
5648           char buf[40];                                                 \
5649           sprintf_vma (buf, section->sh_entsize);                       \
5650           /* Note: coded this way so that there is a single string for  \
5651              translation.  */ \
5652           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5653           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5654                    (unsigned) expected_entsize);                        \
5655           section->sh_entsize = expected_entsize;                       \
5656         }                                                               \
5657     }                                                                   \
5658   while (0)
5659
5660 #define CHECK_ENTSIZE(section, i, type)                                 \
5661   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5662                         sizeof (Elf64_External_##type))
5663
5664   for (i = 0, section = section_headers;
5665        i < elf_header.e_shnum;
5666        i++, section++)
5667     {
5668       char * name = SECTION_NAME (section);
5669
5670       if (section->sh_type == SHT_DYNSYM)
5671         {
5672           if (dynamic_symbols != NULL)
5673             {
5674               error (_("File contains multiple dynamic symbol tables\n"));
5675               continue;
5676             }
5677
5678           CHECK_ENTSIZE (section, i, Sym);
5679           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5680         }
5681       else if (section->sh_type == SHT_STRTAB
5682                && streq (name, ".dynstr"))
5683         {
5684           if (dynamic_strings != NULL)
5685             {
5686               error (_("File contains multiple dynamic string tables\n"));
5687               continue;
5688             }
5689
5690           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5691                                                1, section->sh_size,
5692                                                _("dynamic strings"));
5693           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5694         }
5695       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5696         {
5697           elf_section_list * entry = xmalloc (sizeof * entry);
5698           entry->hdr = section;
5699           entry->next = symtab_shndx_list;
5700           symtab_shndx_list = entry;
5701         }
5702       else if (section->sh_type == SHT_SYMTAB)
5703         CHECK_ENTSIZE (section, i, Sym);
5704       else if (section->sh_type == SHT_GROUP)
5705         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5706       else if (section->sh_type == SHT_REL)
5707         CHECK_ENTSIZE (section, i, Rel);
5708       else if (section->sh_type == SHT_RELA)
5709         CHECK_ENTSIZE (section, i, Rela);
5710       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5711                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5712                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5713                 || do_debug_str || do_debug_loc || do_debug_ranges
5714                 || do_debug_addr || do_debug_cu_index)
5715                && (const_strneq (name, ".debug_")
5716                    || const_strneq (name, ".zdebug_")))
5717         {
5718           if (name[1] == 'z')
5719             name += sizeof (".zdebug_") - 1;
5720           else
5721             name += sizeof (".debug_") - 1;
5722
5723           if (do_debugging
5724               || (do_debug_info     && const_strneq (name, "info"))
5725               || (do_debug_info     && const_strneq (name, "types"))
5726               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5727               || (do_debug_lines    && strcmp (name, "line") == 0)
5728               || (do_debug_lines    && const_strneq (name, "line."))
5729               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5730               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5731               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5732               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5733               || (do_debug_aranges  && const_strneq (name, "aranges"))
5734               || (do_debug_ranges   && const_strneq (name, "ranges"))
5735               || (do_debug_frames   && const_strneq (name, "frame"))
5736               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5737               || (do_debug_macinfo  && const_strneq (name, "macro"))
5738               || (do_debug_str      && const_strneq (name, "str"))
5739               || (do_debug_loc      && const_strneq (name, "loc"))
5740               || (do_debug_addr     && const_strneq (name, "addr"))
5741               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5742               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5743               )
5744             request_dump_bynumber (i, DEBUG_DUMP);
5745         }
5746       /* Linkonce section to be combined with .debug_info at link time.  */
5747       else if ((do_debugging || do_debug_info)
5748                && const_strneq (name, ".gnu.linkonce.wi."))
5749         request_dump_bynumber (i, DEBUG_DUMP);
5750       else if (do_debug_frames && streq (name, ".eh_frame"))
5751         request_dump_bynumber (i, DEBUG_DUMP);
5752       else if (do_gdb_index && streq (name, ".gdb_index"))
5753         request_dump_bynumber (i, DEBUG_DUMP);
5754       /* Trace sections for Itanium VMS.  */
5755       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5756                 || do_trace_aranges)
5757                && const_strneq (name, ".trace_"))
5758         {
5759           name += sizeof (".trace_") - 1;
5760
5761           if (do_debugging
5762               || (do_trace_info     && streq (name, "info"))
5763               || (do_trace_abbrevs  && streq (name, "abbrev"))
5764               || (do_trace_aranges  && streq (name, "aranges"))
5765               )
5766             request_dump_bynumber (i, DEBUG_DUMP);
5767         }
5768     }
5769
5770   if (! do_sections)
5771     return 1;
5772
5773   if (elf_header.e_shnum > 1)
5774     printf (_("\nSection Headers:\n"));
5775   else
5776     printf (_("\nSection Header:\n"));
5777
5778   if (is_32bit_elf)
5779     {
5780       if (do_section_details)
5781         {
5782           printf (_("  [Nr] Name\n"));
5783           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5784         }
5785       else
5786         printf
5787           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5788     }
5789   else if (do_wide)
5790     {
5791       if (do_section_details)
5792         {
5793           printf (_("  [Nr] Name\n"));
5794           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5795         }
5796       else
5797         printf
5798           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5799     }
5800   else
5801     {
5802       if (do_section_details)
5803         {
5804           printf (_("  [Nr] Name\n"));
5805           printf (_("       Type              Address          Offset            Link\n"));
5806           printf (_("       Size              EntSize          Info              Align\n"));
5807         }
5808       else
5809         {
5810           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5811           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5812         }
5813     }
5814
5815   if (do_section_details)
5816     printf (_("       Flags\n"));
5817
5818   for (i = 0, section = section_headers;
5819        i < elf_header.e_shnum;
5820        i++, section++)
5821     {
5822       printf ("  [%2u] ", i);
5823       if (do_section_details)
5824         printf ("%s\n      ", printable_section_name (section));
5825       else
5826         print_symbol (-17, SECTION_NAME (section));
5827
5828       printf (do_wide ? " %-15s " : " %-15.15s ",
5829               get_section_type_name (section->sh_type));
5830
5831       if (is_32bit_elf)
5832         {
5833           const char * link_too_big = NULL;
5834
5835           print_vma (section->sh_addr, LONG_HEX);
5836
5837           printf ( " %6.6lx %6.6lx %2.2lx",
5838                    (unsigned long) section->sh_offset,
5839                    (unsigned long) section->sh_size,
5840                    (unsigned long) section->sh_entsize);
5841
5842           if (do_section_details)
5843             fputs ("  ", stdout);
5844           else
5845             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5846
5847           if (section->sh_link >= elf_header.e_shnum)
5848             {
5849               link_too_big = "";
5850               /* The sh_link value is out of range.  Normally this indicates
5851                  an error but it can have special values in Solaris binaries.  */
5852               switch (elf_header.e_machine)
5853                 {
5854                 case EM_386:
5855                 case EM_IAMCU:
5856                 case EM_X86_64:
5857                 case EM_L1OM:
5858                 case EM_K1OM:
5859                 case EM_OLD_SPARCV9:
5860                 case EM_SPARC32PLUS:
5861                 case EM_SPARCV9:
5862                 case EM_SPARC:
5863                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5864                     link_too_big = "BEFORE";
5865                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5866                     link_too_big = "AFTER";
5867                   break;
5868                 default:
5869                   break;
5870                 }
5871             }
5872
5873           if (do_section_details)
5874             {
5875               if (link_too_big != NULL && * link_too_big)
5876                 printf ("<%s> ", link_too_big);
5877               else
5878                 printf ("%2u ", section->sh_link);
5879               printf ("%3u %2lu\n", section->sh_info,
5880                       (unsigned long) section->sh_addralign);
5881             }
5882           else
5883             printf ("%2u %3u %2lu\n",
5884                     section->sh_link,
5885                     section->sh_info,
5886                     (unsigned long) section->sh_addralign);
5887
5888           if (link_too_big && ! * link_too_big)
5889             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5890                   i, section->sh_link);
5891         }
5892       else if (do_wide)
5893         {
5894           print_vma (section->sh_addr, LONG_HEX);
5895
5896           if ((long) section->sh_offset == section->sh_offset)
5897             printf (" %6.6lx", (unsigned long) section->sh_offset);
5898           else
5899             {
5900               putchar (' ');
5901               print_vma (section->sh_offset, LONG_HEX);
5902             }
5903
5904           if ((unsigned long) section->sh_size == section->sh_size)
5905             printf (" %6.6lx", (unsigned long) section->sh_size);
5906           else
5907             {
5908               putchar (' ');
5909               print_vma (section->sh_size, LONG_HEX);
5910             }
5911
5912           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5913             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5914           else
5915             {
5916               putchar (' ');
5917               print_vma (section->sh_entsize, LONG_HEX);
5918             }
5919
5920           if (do_section_details)
5921             fputs ("  ", stdout);
5922           else
5923             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5924
5925           printf ("%2u %3u ", section->sh_link, section->sh_info);
5926
5927           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5928             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5929           else
5930             {
5931               print_vma (section->sh_addralign, DEC);
5932               putchar ('\n');
5933             }
5934         }
5935       else if (do_section_details)
5936         {
5937           printf ("       %-15.15s  ",
5938                   get_section_type_name (section->sh_type));
5939           print_vma (section->sh_addr, LONG_HEX);
5940           if ((long) section->sh_offset == section->sh_offset)
5941             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5942           else
5943             {
5944               printf ("  ");
5945               print_vma (section->sh_offset, LONG_HEX);
5946             }
5947           printf ("  %u\n       ", section->sh_link);
5948           print_vma (section->sh_size, LONG_HEX);
5949           putchar (' ');
5950           print_vma (section->sh_entsize, LONG_HEX);
5951
5952           printf ("  %-16u  %lu\n",
5953                   section->sh_info,
5954                   (unsigned long) section->sh_addralign);
5955         }
5956       else
5957         {
5958           putchar (' ');
5959           print_vma (section->sh_addr, LONG_HEX);
5960           if ((long) section->sh_offset == section->sh_offset)
5961             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5962           else
5963             {
5964               printf ("  ");
5965               print_vma (section->sh_offset, LONG_HEX);
5966             }
5967           printf ("\n       ");
5968           print_vma (section->sh_size, LONG_HEX);
5969           printf ("  ");
5970           print_vma (section->sh_entsize, LONG_HEX);
5971
5972           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5973
5974           printf ("     %2u   %3u     %lu\n",
5975                   section->sh_link,
5976                   section->sh_info,
5977                   (unsigned long) section->sh_addralign);
5978         }
5979
5980       if (do_section_details)
5981         {
5982           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5983           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5984             {
5985               /* Minimum section size is 12 bytes for 32-bit compression
5986                  header + 12 bytes for compressed data header.  */
5987               unsigned char buf[24];
5988               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5989               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5990                             sizeof (buf), _("compression header")))
5991                 {
5992                   Elf_Internal_Chdr chdr;
5993                   get_compression_header (&chdr, buf);
5994                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5995                     printf ("       ZLIB, ");
5996                   else
5997                     printf (_("       [<unknown>: 0x%x], "),
5998                             chdr.ch_type);
5999                   print_vma (chdr.ch_size, LONG_HEX);
6000                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6001                 }
6002             }
6003         }
6004     }
6005
6006   if (!do_section_details)
6007     {
6008       /* The ordering of the letters shown here matches the ordering of the
6009          corresponding SHF_xxx values, and hence the order in which these
6010          letters will be displayed to the user.  */
6011       printf (_("Key to Flags:\n\
6012   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6013   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6014   C (compressed), x (unknown), o (OS specific), E (exclude),\n"));
6015       if (elf_header.e_machine == EM_X86_64
6016           || elf_header.e_machine == EM_L1OM
6017           || elf_header.e_machine == EM_K1OM)
6018         printf (_("l (large), "));
6019       else if (elf_header.e_machine == EM_ARM)
6020         printf (_("y (noread), "));
6021       printf ("p (processor specific)\n");
6022     }
6023
6024   return 1;
6025 }
6026
6027 static const char *
6028 get_group_flags (unsigned int flags)
6029 {
6030   static char buff[32];
6031   switch (flags)
6032     {
6033     case 0:
6034       return "";
6035
6036     case GRP_COMDAT:
6037       return "COMDAT ";
6038
6039    default:
6040       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
6041       break;
6042     }
6043   return buff;
6044 }
6045
6046 static int
6047 process_section_groups (FILE * file)
6048 {
6049   Elf_Internal_Shdr * section;
6050   unsigned int i;
6051   struct group * group;
6052   Elf_Internal_Shdr * symtab_sec;
6053   Elf_Internal_Shdr * strtab_sec;
6054   Elf_Internal_Sym * symtab;
6055   unsigned long num_syms;
6056   char * strtab;
6057   size_t strtab_size;
6058
6059   /* Don't process section groups unless needed.  */
6060   if (!do_unwind && !do_section_groups)
6061     return 1;
6062
6063   if (elf_header.e_shnum == 0)
6064     {
6065       if (do_section_groups)
6066         printf (_("\nThere are no sections to group in this file.\n"));
6067
6068       return 1;
6069     }
6070
6071   if (section_headers == NULL)
6072     {
6073       error (_("Section headers are not available!\n"));
6074       /* PR 13622: This can happen with a corrupt ELF header.  */
6075       return 0;
6076     }
6077
6078   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6079                                                      sizeof (struct group *));
6080
6081   if (section_headers_groups == NULL)
6082     {
6083       error (_("Out of memory reading %u section group headers\n"),
6084              elf_header.e_shnum);
6085       return 0;
6086     }
6087
6088   /* Scan the sections for the group section.  */
6089   group_count = 0;
6090   for (i = 0, section = section_headers;
6091        i < elf_header.e_shnum;
6092        i++, section++)
6093     if (section->sh_type == SHT_GROUP)
6094       group_count++;
6095
6096   if (group_count == 0)
6097     {
6098       if (do_section_groups)
6099         printf (_("\nThere are no section groups in this file.\n"));
6100
6101       return 1;
6102     }
6103
6104   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6105
6106   if (section_groups == NULL)
6107     {
6108       error (_("Out of memory reading %lu groups\n"),
6109              (unsigned long) group_count);
6110       return 0;
6111     }
6112
6113   symtab_sec = NULL;
6114   strtab_sec = NULL;
6115   symtab = NULL;
6116   num_syms = 0;
6117   strtab = NULL;
6118   strtab_size = 0;
6119   for (i = 0, section = section_headers, group = section_groups;
6120        i < elf_header.e_shnum;
6121        i++, section++)
6122     {
6123       if (section->sh_type == SHT_GROUP)
6124         {
6125           const char * name = printable_section_name (section);
6126           const char * group_name;
6127           unsigned char * start;
6128           unsigned char * indices;
6129           unsigned int entry, j, size;
6130           Elf_Internal_Shdr * sec;
6131           Elf_Internal_Sym * sym;
6132
6133           /* Get the symbol table.  */
6134           if (section->sh_link >= elf_header.e_shnum
6135               || ((sec = section_headers + section->sh_link)->sh_type
6136                   != SHT_SYMTAB))
6137             {
6138               error (_("Bad sh_link in group section `%s'\n"), name);
6139               continue;
6140             }
6141
6142           if (symtab_sec != sec)
6143             {
6144               symtab_sec = sec;
6145               if (symtab)
6146                 free (symtab);
6147               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6148             }
6149
6150           if (symtab == NULL)
6151             {
6152               error (_("Corrupt header in group section `%s'\n"), name);
6153               continue;
6154             }
6155
6156           if (section->sh_info >= num_syms)
6157             {
6158               error (_("Bad sh_info in group section `%s'\n"), name);
6159               continue;
6160             }
6161
6162           sym = symtab + section->sh_info;
6163
6164           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6165             {
6166               if (sym->st_shndx == 0
6167                   || sym->st_shndx >= elf_header.e_shnum)
6168                 {
6169                   error (_("Bad sh_info in group section `%s'\n"), name);
6170                   continue;
6171                 }
6172
6173               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6174               strtab_sec = NULL;
6175               if (strtab)
6176                 free (strtab);
6177               strtab = NULL;
6178               strtab_size = 0;
6179             }
6180           else
6181             {
6182               /* Get the string table.  */
6183               if (symtab_sec->sh_link >= elf_header.e_shnum)
6184                 {
6185                   strtab_sec = NULL;
6186                   if (strtab)
6187                     free (strtab);
6188                   strtab = NULL;
6189                   strtab_size = 0;
6190                 }
6191               else if (strtab_sec
6192                        != (sec = section_headers + symtab_sec->sh_link))
6193                 {
6194                   strtab_sec = sec;
6195                   if (strtab)
6196                     free (strtab);
6197
6198                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6199                                               1, strtab_sec->sh_size,
6200                                               _("string table"));
6201                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6202                 }
6203               group_name = sym->st_name < strtab_size
6204                 ? strtab + sym->st_name : _("<corrupt>");
6205             }
6206
6207           /* PR 17531: file: loop.  */
6208           if (section->sh_entsize > section->sh_size)
6209             {
6210               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6211                      printable_section_name (section),
6212                      (unsigned long) section->sh_entsize,
6213                      (unsigned long) section->sh_size);
6214               break;
6215             }
6216
6217           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6218                                               1, section->sh_size,
6219                                               _("section data"));
6220           if (start == NULL)
6221             continue;
6222
6223           indices = start;
6224           size = (section->sh_size / section->sh_entsize) - 1;
6225           entry = byte_get (indices, 4);
6226           indices += 4;
6227
6228           if (do_section_groups)
6229             {
6230               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6231                       get_group_flags (entry), i, name, group_name, size);
6232
6233               printf (_("   [Index]    Name\n"));
6234             }
6235
6236           group->group_index = i;
6237
6238           for (j = 0; j < size; j++)
6239             {
6240               struct group_list * g;
6241
6242               entry = byte_get (indices, 4);
6243               indices += 4;
6244
6245               if (entry >= elf_header.e_shnum)
6246                 {
6247                   static unsigned num_group_errors = 0;
6248
6249                   if (num_group_errors ++ < 10)
6250                     {
6251                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6252                              entry, i, elf_header.e_shnum - 1);
6253                       if (num_group_errors == 10)
6254                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6255                     }
6256                   continue;
6257                 }
6258
6259               if (section_headers_groups [entry] != NULL)
6260                 {
6261                   if (entry)
6262                     {
6263                       static unsigned num_errs = 0;
6264
6265                       if (num_errs ++ < 10)
6266                         {
6267                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6268                                  entry, i,
6269                                  section_headers_groups [entry]->group_index);
6270                           if (num_errs == 10)
6271                             warn (_("Further error messages about already contained group sections suppressed\n"));
6272                         }
6273                       continue;
6274                     }
6275                   else
6276                     {
6277                       /* Intel C/C++ compiler may put section 0 in a
6278                          section group. We just warn it the first time
6279                          and ignore it afterwards.  */
6280                       static int warned = 0;
6281                       if (!warned)
6282                         {
6283                           error (_("section 0 in group section [%5u]\n"),
6284                                  section_headers_groups [entry]->group_index);
6285                           warned++;
6286                         }
6287                     }
6288                 }
6289
6290               section_headers_groups [entry] = group;
6291
6292               if (do_section_groups)
6293                 {
6294                   sec = section_headers + entry;
6295                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6296                 }
6297
6298               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6299               g->section_index = entry;
6300               g->next = group->root;
6301               group->root = g;
6302             }
6303
6304           if (start)
6305             free (start);
6306
6307           group++;
6308         }
6309     }
6310
6311   if (symtab)
6312     free (symtab);
6313   if (strtab)
6314     free (strtab);
6315   return 1;
6316 }
6317
6318 /* Data used to display dynamic fixups.  */
6319
6320 struct ia64_vms_dynfixup
6321 {
6322   bfd_vma needed_ident;         /* Library ident number.  */
6323   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6324   bfd_vma fixup_needed;         /* Index of the library.  */
6325   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6326   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6327 };
6328
6329 /* Data used to display dynamic relocations.  */
6330
6331 struct ia64_vms_dynimgrela
6332 {
6333   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6334   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6335 };
6336
6337 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6338    library).  */
6339
6340 static void
6341 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6342                               const char *strtab, unsigned int strtab_sz)
6343 {
6344   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6345   long i;
6346   const char *lib_name;
6347
6348   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6349                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6350                    _("dynamic section image fixups"));
6351   if (!imfs)
6352     return;
6353
6354   if (fixup->needed < strtab_sz)
6355     lib_name = strtab + fixup->needed;
6356   else
6357     {
6358       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6359             (unsigned long) fixup->needed);
6360       lib_name = "???";
6361     }
6362   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6363           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6364   printf
6365     (_("Seg Offset           Type                             SymVec DataType\n"));
6366
6367   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6368     {
6369       unsigned int type;
6370       const char *rtype;
6371
6372       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6373       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6374       type = BYTE_GET (imfs [i].type);
6375       rtype = elf_ia64_reloc_type (type);
6376       if (rtype == NULL)
6377         printf (" 0x%08x                       ", type);
6378       else
6379         printf (" %-32s ", rtype);
6380       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6381       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6382     }
6383
6384   free (imfs);
6385 }
6386
6387 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6388
6389 static void
6390 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6391 {
6392   Elf64_External_VMS_IMAGE_RELA *imrs;
6393   long i;
6394
6395   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6396                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6397                    _("dynamic section image relocations"));
6398   if (!imrs)
6399     return;
6400
6401   printf (_("\nImage relocs\n"));
6402   printf
6403     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6404
6405   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6406     {
6407       unsigned int type;
6408       const char *rtype;
6409
6410       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6411       printf ("%08" BFD_VMA_FMT "x ",
6412               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6413       type = BYTE_GET (imrs [i].type);
6414       rtype = elf_ia64_reloc_type (type);
6415       if (rtype == NULL)
6416         printf ("0x%08x                      ", type);
6417       else
6418         printf ("%-31s ", rtype);
6419       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6420       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6421       printf ("%08" BFD_VMA_FMT "x\n",
6422               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6423     }
6424
6425   free (imrs);
6426 }
6427
6428 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6429
6430 static int
6431 process_ia64_vms_dynamic_relocs (FILE *file)
6432 {
6433   struct ia64_vms_dynfixup fixup;
6434   struct ia64_vms_dynimgrela imgrela;
6435   Elf_Internal_Dyn *entry;
6436   int res = 0;
6437   bfd_vma strtab_off = 0;
6438   bfd_vma strtab_sz = 0;
6439   char *strtab = NULL;
6440
6441   memset (&fixup, 0, sizeof (fixup));
6442   memset (&imgrela, 0, sizeof (imgrela));
6443
6444   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6445   for (entry = dynamic_section;
6446        entry < dynamic_section + dynamic_nent;
6447        entry++)
6448     {
6449       switch (entry->d_tag)
6450         {
6451         case DT_IA_64_VMS_STRTAB_OFFSET:
6452           strtab_off = entry->d_un.d_val;
6453           break;
6454         case DT_STRSZ:
6455           strtab_sz = entry->d_un.d_val;
6456           if (strtab == NULL)
6457             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6458                                1, strtab_sz, _("dynamic string section"));
6459           break;
6460
6461         case DT_IA_64_VMS_NEEDED_IDENT:
6462           fixup.needed_ident = entry->d_un.d_val;
6463           break;
6464         case DT_NEEDED:
6465           fixup.needed = entry->d_un.d_val;
6466           break;
6467         case DT_IA_64_VMS_FIXUP_NEEDED:
6468           fixup.fixup_needed = entry->d_un.d_val;
6469           break;
6470         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6471           fixup.fixup_rela_cnt = entry->d_un.d_val;
6472           break;
6473         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6474           fixup.fixup_rela_off = entry->d_un.d_val;
6475           res++;
6476           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6477           break;
6478
6479         case DT_IA_64_VMS_IMG_RELA_CNT:
6480           imgrela.img_rela_cnt = entry->d_un.d_val;
6481           break;
6482         case DT_IA_64_VMS_IMG_RELA_OFF:
6483           imgrela.img_rela_off = entry->d_un.d_val;
6484           res++;
6485           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6486           break;
6487
6488         default:
6489           break;
6490         }
6491     }
6492
6493   if (strtab != NULL)
6494     free (strtab);
6495
6496   return res;
6497 }
6498
6499 static struct
6500 {
6501   const char * name;
6502   int reloc;
6503   int size;
6504   int rela;
6505 } dynamic_relocations [] =
6506 {
6507     { "REL", DT_REL, DT_RELSZ, FALSE },
6508     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6509     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6510 };
6511
6512 /* Process the reloc section.  */
6513
6514 static int
6515 process_relocs (FILE * file)
6516 {
6517   unsigned long rel_size;
6518   unsigned long rel_offset;
6519
6520
6521   if (!do_reloc)
6522     return 1;
6523
6524   if (do_using_dynamic)
6525     {
6526       int is_rela;
6527       const char * name;
6528       int has_dynamic_reloc;
6529       unsigned int i;
6530
6531       has_dynamic_reloc = 0;
6532
6533       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6534         {
6535           is_rela = dynamic_relocations [i].rela;
6536           name = dynamic_relocations [i].name;
6537           rel_size = dynamic_info [dynamic_relocations [i].size];
6538           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6539
6540           has_dynamic_reloc |= rel_size;
6541
6542           if (is_rela == UNKNOWN)
6543             {
6544               if (dynamic_relocations [i].reloc == DT_JMPREL)
6545                 switch (dynamic_info[DT_PLTREL])
6546                   {
6547                   case DT_REL:
6548                     is_rela = FALSE;
6549                     break;
6550                   case DT_RELA:
6551                     is_rela = TRUE;
6552                     break;
6553                   }
6554             }
6555
6556           if (rel_size)
6557             {
6558               printf
6559                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6560                  name, rel_offset, rel_size);
6561
6562               dump_relocations (file,
6563                                 offset_from_vma (file, rel_offset, rel_size),
6564                                 rel_size,
6565                                 dynamic_symbols, num_dynamic_syms,
6566                                 dynamic_strings, dynamic_strings_length,
6567                                 is_rela, 1);
6568             }
6569         }
6570
6571       if (is_ia64_vms ())
6572         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6573
6574       if (! has_dynamic_reloc)
6575         printf (_("\nThere are no dynamic relocations in this file.\n"));
6576     }
6577   else
6578     {
6579       Elf_Internal_Shdr * section;
6580       unsigned long i;
6581       int found = 0;
6582
6583       for (i = 0, section = section_headers;
6584            i < elf_header.e_shnum;
6585            i++, section++)
6586         {
6587           if (   section->sh_type != SHT_RELA
6588               && section->sh_type != SHT_REL)
6589             continue;
6590
6591           rel_offset = section->sh_offset;
6592           rel_size   = section->sh_size;
6593
6594           if (rel_size)
6595             {
6596               Elf_Internal_Shdr * strsec;
6597               int is_rela;
6598
6599               printf (_("\nRelocation section "));
6600
6601               if (string_table == NULL)
6602                 printf ("%d", section->sh_name);
6603               else
6604                 printf ("'%s'", printable_section_name (section));
6605
6606               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6607                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6608
6609               is_rela = section->sh_type == SHT_RELA;
6610
6611               if (section->sh_link != 0
6612                   && section->sh_link < elf_header.e_shnum)
6613                 {
6614                   Elf_Internal_Shdr * symsec;
6615                   Elf_Internal_Sym *  symtab;
6616                   unsigned long nsyms;
6617                   unsigned long strtablen = 0;
6618                   char * strtab = NULL;
6619
6620                   symsec = section_headers + section->sh_link;
6621                   if (symsec->sh_type != SHT_SYMTAB
6622                       && symsec->sh_type != SHT_DYNSYM)
6623                     continue;
6624
6625                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6626
6627                   if (symtab == NULL)
6628                     continue;
6629
6630                   if (symsec->sh_link != 0
6631                       && symsec->sh_link < elf_header.e_shnum)
6632                     {
6633                       strsec = section_headers + symsec->sh_link;
6634
6635                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6636                                                   1, strsec->sh_size,
6637                                                   _("string table"));
6638                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6639                     }
6640
6641                   dump_relocations (file, rel_offset, rel_size,
6642                                     symtab, nsyms, strtab, strtablen,
6643                                     is_rela,
6644                                     symsec->sh_type == SHT_DYNSYM);
6645                   if (strtab)
6646                     free (strtab);
6647                   free (symtab);
6648                 }
6649               else
6650                 dump_relocations (file, rel_offset, rel_size,
6651                                   NULL, 0, NULL, 0, is_rela, 0);
6652
6653               found = 1;
6654             }
6655         }
6656
6657       if (! found)
6658         printf (_("\nThere are no relocations in this file.\n"));
6659     }
6660
6661   return 1;
6662 }
6663
6664 /* An absolute address consists of a section and an offset.  If the
6665    section is NULL, the offset itself is the address, otherwise, the
6666    address equals to LOAD_ADDRESS(section) + offset.  */
6667
6668 struct absaddr
6669 {
6670   unsigned short section;
6671   bfd_vma offset;
6672 };
6673
6674 #define ABSADDR(a) \
6675   ((a).section \
6676    ? section_headers [(a).section].sh_addr + (a).offset \
6677    : (a).offset)
6678
6679 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6680    name, if found, and the offset from the symbol to ADDR.  */
6681
6682 static void
6683 find_symbol_for_address (Elf_Internal_Sym * symtab,
6684                          unsigned long      nsyms,
6685                          const char *       strtab,
6686                          unsigned long      strtab_size,
6687                          struct absaddr     addr,
6688                          const char **      symname,
6689                          bfd_vma *          offset)
6690 {
6691   bfd_vma dist = 0x100000;
6692   Elf_Internal_Sym * sym;
6693   Elf_Internal_Sym * beg;
6694   Elf_Internal_Sym * end;
6695   Elf_Internal_Sym * best = NULL;
6696
6697   REMOVE_ARCH_BITS (addr.offset);
6698   beg = symtab;
6699   end = symtab + nsyms;
6700
6701   while (beg < end)
6702     {
6703       bfd_vma value;
6704
6705       sym = beg + (end - beg) / 2;
6706
6707       value = sym->st_value;
6708       REMOVE_ARCH_BITS (value);
6709
6710       if (sym->st_name != 0
6711           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6712           && addr.offset >= value
6713           && addr.offset - value < dist)
6714         {
6715           best = sym;
6716           dist = addr.offset - value;
6717           if (!dist)
6718             break;
6719         }
6720
6721       if (addr.offset < value)
6722         end = sym;
6723       else
6724         beg = sym + 1;
6725     }
6726
6727   if (best)
6728     {
6729       *symname = (best->st_name >= strtab_size
6730                   ? _("<corrupt>") : strtab + best->st_name);
6731       *offset = dist;
6732       return;
6733     }
6734
6735   *symname = NULL;
6736   *offset = addr.offset;
6737 }
6738
6739 static int
6740 symcmp (const void *p, const void *q)
6741 {
6742   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6743   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6744
6745   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6746 }
6747
6748 /* Process the unwind section.  */
6749
6750 #include "unwind-ia64.h"
6751
6752 struct ia64_unw_table_entry
6753 {
6754   struct absaddr start;
6755   struct absaddr end;
6756   struct absaddr info;
6757 };
6758
6759 struct ia64_unw_aux_info
6760 {
6761   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6762   unsigned long table_len;              /* Length of unwind table.  */
6763   unsigned char * info;                 /* Unwind info.  */
6764   unsigned long info_size;              /* Size of unwind info.  */
6765   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6766   bfd_vma seg_base;                     /* Starting address of segment.  */
6767   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6768   unsigned long nsyms;                  /* Number of symbols.  */
6769   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6770   unsigned long nfuns;                  /* Number of entries in funtab.  */
6771   char * strtab;                        /* The string table.  */
6772   unsigned long strtab_size;            /* Size of string table.  */
6773 };
6774
6775 static void
6776 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6777 {
6778   struct ia64_unw_table_entry * tp;
6779   unsigned long j, nfuns;
6780   int in_body;
6781
6782   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6783   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6784     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6785       aux->funtab[nfuns++] = aux->symtab[j];
6786   aux->nfuns = nfuns;
6787   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6788
6789   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6790     {
6791       bfd_vma stamp;
6792       bfd_vma offset;
6793       const unsigned char * dp;
6794       const unsigned char * head;
6795       const unsigned char * end;
6796       const char * procname;
6797
6798       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6799                                aux->strtab_size, tp->start, &procname, &offset);
6800
6801       fputs ("\n<", stdout);
6802
6803       if (procname)
6804         {
6805           fputs (procname, stdout);
6806
6807           if (offset)
6808             printf ("+%lx", (unsigned long) offset);
6809         }
6810
6811       fputs (">: [", stdout);
6812       print_vma (tp->start.offset, PREFIX_HEX);
6813       fputc ('-', stdout);
6814       print_vma (tp->end.offset, PREFIX_HEX);
6815       printf ("], info at +0x%lx\n",
6816               (unsigned long) (tp->info.offset - aux->seg_base));
6817
6818       /* PR 17531: file: 86232b32.  */
6819       if (aux->info == NULL)
6820         continue;
6821
6822       /* PR 17531: file: 0997b4d1.  */
6823       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6824         {
6825           warn (_("Invalid offset %lx in table entry %ld\n"),
6826                 (long) tp->info.offset, (long) (tp - aux->table));
6827           continue;
6828         }
6829
6830       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6831       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6832
6833       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6834               (unsigned) UNW_VER (stamp),
6835               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6836               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6837               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6838               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6839
6840       if (UNW_VER (stamp) != 1)
6841         {
6842           printf (_("\tUnknown version.\n"));
6843           continue;
6844         }
6845
6846       in_body = 0;
6847       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6848       /* PR 17531: file: 16ceda89.  */
6849       if (end > aux->info + aux->info_size)
6850         end = aux->info + aux->info_size;
6851       for (dp = head + 8; dp < end;)
6852         dp = unw_decode (dp, in_body, & in_body, end);
6853     }
6854
6855   free (aux->funtab);
6856 }
6857
6858 static bfd_boolean
6859 slurp_ia64_unwind_table (FILE * file,
6860                          struct ia64_unw_aux_info * aux,
6861                          Elf_Internal_Shdr * sec)
6862 {
6863   unsigned long size, nrelas, i;
6864   Elf_Internal_Phdr * seg;
6865   struct ia64_unw_table_entry * tep;
6866   Elf_Internal_Shdr * relsec;
6867   Elf_Internal_Rela * rela;
6868   Elf_Internal_Rela * rp;
6869   unsigned char * table;
6870   unsigned char * tp;
6871   Elf_Internal_Sym * sym;
6872   const char * relname;
6873
6874   aux->table_len = 0;
6875
6876   /* First, find the starting address of the segment that includes
6877      this section: */
6878
6879   if (elf_header.e_phnum)
6880     {
6881       if (! get_program_headers (file))
6882           return FALSE;
6883
6884       for (seg = program_headers;
6885            seg < program_headers + elf_header.e_phnum;
6886            ++seg)
6887         {
6888           if (seg->p_type != PT_LOAD)
6889             continue;
6890
6891           if (sec->sh_addr >= seg->p_vaddr
6892               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6893             {
6894               aux->seg_base = seg->p_vaddr;
6895               break;
6896             }
6897         }
6898     }
6899
6900   /* Second, build the unwind table from the contents of the unwind section:  */
6901   size = sec->sh_size;
6902   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6903                                       _("unwind table"));
6904   if (!table)
6905     return FALSE;
6906
6907   aux->table_len = size / (3 * eh_addr_size);
6908   aux->table = (struct ia64_unw_table_entry *)
6909     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6910   tep = aux->table;
6911
6912   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6913     {
6914       tep->start.section = SHN_UNDEF;
6915       tep->end.section   = SHN_UNDEF;
6916       tep->info.section  = SHN_UNDEF;
6917       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6918       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6919       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6920       tep->start.offset += aux->seg_base;
6921       tep->end.offset   += aux->seg_base;
6922       tep->info.offset  += aux->seg_base;
6923     }
6924   free (table);
6925
6926   /* Third, apply any relocations to the unwind table:  */
6927   for (relsec = section_headers;
6928        relsec < section_headers + elf_header.e_shnum;
6929        ++relsec)
6930     {
6931       if (relsec->sh_type != SHT_RELA
6932           || relsec->sh_info >= elf_header.e_shnum
6933           || section_headers + relsec->sh_info != sec)
6934         continue;
6935
6936       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6937                               & rela, & nrelas))
6938         {
6939           free (aux->table);
6940           aux->table = NULL;
6941           aux->table_len = 0;
6942           return FALSE;
6943         }
6944
6945       for (rp = rela; rp < rela + nrelas; ++rp)
6946         {
6947           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6948           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6949
6950           /* PR 17531: file: 9fa67536.  */
6951           if (relname == NULL)
6952             {
6953               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6954               continue;
6955             }
6956
6957           if (! const_strneq (relname, "R_IA64_SEGREL"))
6958             {
6959               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6960               continue;
6961             }
6962
6963           i = rp->r_offset / (3 * eh_addr_size);
6964
6965           /* PR 17531: file: 5bc8d9bf.  */
6966           if (i >= aux->table_len)
6967             {
6968               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6969               continue;
6970             }
6971
6972           switch (rp->r_offset / eh_addr_size % 3)
6973             {
6974             case 0:
6975               aux->table[i].start.section = sym->st_shndx;
6976               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6977               break;
6978             case 1:
6979               aux->table[i].end.section   = sym->st_shndx;
6980               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6981               break;
6982             case 2:
6983               aux->table[i].info.section  = sym->st_shndx;
6984               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6985               break;
6986             default:
6987               break;
6988             }
6989         }
6990
6991       free (rela);
6992     }
6993
6994   return TRUE;
6995 }
6996
6997 static void
6998 ia64_process_unwind (FILE * file)
6999 {
7000   Elf_Internal_Shdr * sec;
7001   Elf_Internal_Shdr * unwsec = NULL;
7002   Elf_Internal_Shdr * strsec;
7003   unsigned long i, unwcount = 0, unwstart = 0;
7004   struct ia64_unw_aux_info aux;
7005
7006   memset (& aux, 0, sizeof (aux));
7007
7008   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7009     {
7010       if (sec->sh_type == SHT_SYMTAB
7011           && sec->sh_link < elf_header.e_shnum)
7012         {
7013           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7014
7015           strsec = section_headers + sec->sh_link;
7016           if (aux.strtab != NULL)
7017             {
7018               error (_("Multiple auxillary string tables encountered\n"));
7019               free (aux.strtab);
7020             }
7021           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7022                                           1, strsec->sh_size,
7023                                           _("string table"));
7024           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7025         }
7026       else if (sec->sh_type == SHT_IA_64_UNWIND)
7027         unwcount++;
7028     }
7029
7030   if (!unwcount)
7031     printf (_("\nThere are no unwind sections in this file.\n"));
7032
7033   while (unwcount-- > 0)
7034     {
7035       char * suffix;
7036       size_t len, len2;
7037
7038       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7039            i < elf_header.e_shnum; ++i, ++sec)
7040         if (sec->sh_type == SHT_IA_64_UNWIND)
7041           {
7042             unwsec = sec;
7043             break;
7044           }
7045       /* We have already counted the number of SHT_IA64_UNWIND
7046          sections so the loop above should never fail.  */
7047       assert (unwsec != NULL);
7048
7049       unwstart = i + 1;
7050       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7051
7052       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7053         {
7054           /* We need to find which section group it is in.  */
7055           struct group_list * g;
7056
7057           if (section_headers_groups == NULL
7058               || section_headers_groups [i] == NULL)
7059             i = elf_header.e_shnum;
7060           else
7061             {
7062               g = section_headers_groups [i]->root;
7063
7064               for (; g != NULL; g = g->next)
7065                 {
7066                   sec = section_headers + g->section_index;
7067
7068                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7069                     break;
7070                 }
7071
7072               if (g == NULL)
7073                 i = elf_header.e_shnum;
7074             }
7075         }
7076       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7077         {
7078           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7079           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7080           suffix = SECTION_NAME (unwsec) + len;
7081           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7082                ++i, ++sec)
7083             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7084                 && streq (SECTION_NAME (sec) + len2, suffix))
7085               break;
7086         }
7087       else
7088         {
7089           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7090              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7091           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7092           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7093           suffix = "";
7094           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7095             suffix = SECTION_NAME (unwsec) + len;
7096           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7097                ++i, ++sec)
7098             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7099                 && streq (SECTION_NAME (sec) + len2, suffix))
7100               break;
7101         }
7102
7103       if (i == elf_header.e_shnum)
7104         {
7105           printf (_("\nCould not find unwind info section for "));
7106
7107           if (string_table == NULL)
7108             printf ("%d", unwsec->sh_name);
7109           else
7110             printf ("'%s'", printable_section_name (unwsec));
7111         }
7112       else
7113         {
7114           aux.info_addr = sec->sh_addr;
7115           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7116                                                  sec->sh_size,
7117                                                  _("unwind info"));
7118           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7119
7120           printf (_("\nUnwind section "));
7121
7122           if (string_table == NULL)
7123             printf ("%d", unwsec->sh_name);
7124           else
7125             printf ("'%s'", printable_section_name (unwsec));
7126
7127           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7128                   (unsigned long) unwsec->sh_offset,
7129                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7130
7131           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7132               && aux.table_len > 0)
7133             dump_ia64_unwind (& aux);
7134
7135           if (aux.table)
7136             free ((char *) aux.table);
7137           if (aux.info)
7138             free ((char *) aux.info);
7139           aux.table = NULL;
7140           aux.info = NULL;
7141         }
7142     }
7143
7144   if (aux.symtab)
7145     free (aux.symtab);
7146   if (aux.strtab)
7147     free ((char *) aux.strtab);
7148 }
7149
7150 struct hppa_unw_table_entry
7151   {
7152     struct absaddr start;
7153     struct absaddr end;
7154     unsigned int Cannot_unwind:1;               /* 0 */
7155     unsigned int Millicode:1;                   /* 1 */
7156     unsigned int Millicode_save_sr0:1;          /* 2 */
7157     unsigned int Region_description:2;          /* 3..4 */
7158     unsigned int reserved1:1;                   /* 5 */
7159     unsigned int Entry_SR:1;                    /* 6 */
7160     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7161     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7162     unsigned int Args_stored:1;                 /* 16 */
7163     unsigned int Variable_Frame:1;              /* 17 */
7164     unsigned int Separate_Package_Body:1;       /* 18 */
7165     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7166     unsigned int Stack_Overflow_Check:1;        /* 20 */
7167     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7168     unsigned int Ada_Region:1;                  /* 22 */
7169     unsigned int cxx_info:1;                    /* 23 */
7170     unsigned int cxx_try_catch:1;               /* 24 */
7171     unsigned int sched_entry_seq:1;             /* 25 */
7172     unsigned int reserved2:1;                   /* 26 */
7173     unsigned int Save_SP:1;                     /* 27 */
7174     unsigned int Save_RP:1;                     /* 28 */
7175     unsigned int Save_MRP_in_frame:1;           /* 29 */
7176     unsigned int extn_ptr_defined:1;            /* 30 */
7177     unsigned int Cleanup_defined:1;             /* 31 */
7178
7179     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7180     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7181     unsigned int Large_frame:1;                 /* 2 */
7182     unsigned int Pseudo_SP_Set:1;               /* 3 */
7183     unsigned int reserved4:1;                   /* 4 */
7184     unsigned int Total_frame_size:27;           /* 5..31 */
7185   };
7186
7187 struct hppa_unw_aux_info
7188 {
7189   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7190   unsigned long table_len;              /* Length of unwind table.  */
7191   bfd_vma seg_base;                     /* Starting address of segment.  */
7192   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7193   unsigned long nsyms;                  /* Number of symbols.  */
7194   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7195   unsigned long nfuns;                  /* Number of entries in funtab.  */
7196   char * strtab;                        /* The string table.  */
7197   unsigned long strtab_size;            /* Size of string table.  */
7198 };
7199
7200 static void
7201 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7202 {
7203   struct hppa_unw_table_entry * tp;
7204   unsigned long j, nfuns;
7205
7206   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7207   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7208     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7209       aux->funtab[nfuns++] = aux->symtab[j];
7210   aux->nfuns = nfuns;
7211   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7212
7213   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7214     {
7215       bfd_vma offset;
7216       const char * procname;
7217
7218       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7219                                aux->strtab_size, tp->start, &procname,
7220                                &offset);
7221
7222       fputs ("\n<", stdout);
7223
7224       if (procname)
7225         {
7226           fputs (procname, stdout);
7227
7228           if (offset)
7229             printf ("+%lx", (unsigned long) offset);
7230         }
7231
7232       fputs (">: [", stdout);
7233       print_vma (tp->start.offset, PREFIX_HEX);
7234       fputc ('-', stdout);
7235       print_vma (tp->end.offset, PREFIX_HEX);
7236       printf ("]\n\t");
7237
7238 #define PF(_m) if (tp->_m) printf (#_m " ");
7239 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7240       PF(Cannot_unwind);
7241       PF(Millicode);
7242       PF(Millicode_save_sr0);
7243       /* PV(Region_description);  */
7244       PF(Entry_SR);
7245       PV(Entry_FR);
7246       PV(Entry_GR);
7247       PF(Args_stored);
7248       PF(Variable_Frame);
7249       PF(Separate_Package_Body);
7250       PF(Frame_Extension_Millicode);
7251       PF(Stack_Overflow_Check);
7252       PF(Two_Instruction_SP_Increment);
7253       PF(Ada_Region);
7254       PF(cxx_info);
7255       PF(cxx_try_catch);
7256       PF(sched_entry_seq);
7257       PF(Save_SP);
7258       PF(Save_RP);
7259       PF(Save_MRP_in_frame);
7260       PF(extn_ptr_defined);
7261       PF(Cleanup_defined);
7262       PF(MPE_XL_interrupt_marker);
7263       PF(HP_UX_interrupt_marker);
7264       PF(Large_frame);
7265       PF(Pseudo_SP_Set);
7266       PV(Total_frame_size);
7267 #undef PF
7268 #undef PV
7269     }
7270
7271   printf ("\n");
7272
7273   free (aux->funtab);
7274 }
7275
7276 static int
7277 slurp_hppa_unwind_table (FILE * file,
7278                          struct hppa_unw_aux_info * aux,
7279                          Elf_Internal_Shdr * sec)
7280 {
7281   unsigned long size, unw_ent_size, nentries, nrelas, i;
7282   Elf_Internal_Phdr * seg;
7283   struct hppa_unw_table_entry * tep;
7284   Elf_Internal_Shdr * relsec;
7285   Elf_Internal_Rela * rela;
7286   Elf_Internal_Rela * rp;
7287   unsigned char * table;
7288   unsigned char * tp;
7289   Elf_Internal_Sym * sym;
7290   const char * relname;
7291
7292   /* First, find the starting address of the segment that includes
7293      this section.  */
7294
7295   if (elf_header.e_phnum)
7296     {
7297       if (! get_program_headers (file))
7298         return 0;
7299
7300       for (seg = program_headers;
7301            seg < program_headers + elf_header.e_phnum;
7302            ++seg)
7303         {
7304           if (seg->p_type != PT_LOAD)
7305             continue;
7306
7307           if (sec->sh_addr >= seg->p_vaddr
7308               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7309             {
7310               aux->seg_base = seg->p_vaddr;
7311               break;
7312             }
7313         }
7314     }
7315
7316   /* Second, build the unwind table from the contents of the unwind
7317      section.  */
7318   size = sec->sh_size;
7319   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7320                                       _("unwind table"));
7321   if (!table)
7322     return 0;
7323
7324   unw_ent_size = 16;
7325   nentries = size / unw_ent_size;
7326   size = unw_ent_size * nentries;
7327
7328   tep = aux->table = (struct hppa_unw_table_entry *)
7329       xcmalloc (nentries, sizeof (aux->table[0]));
7330
7331   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7332     {
7333       unsigned int tmp1, tmp2;
7334
7335       tep->start.section = SHN_UNDEF;
7336       tep->end.section   = SHN_UNDEF;
7337
7338       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7339       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7340       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7341       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7342
7343       tep->start.offset += aux->seg_base;
7344       tep->end.offset   += aux->seg_base;
7345
7346       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7347       tep->Millicode = (tmp1 >> 30) & 0x1;
7348       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7349       tep->Region_description = (tmp1 >> 27) & 0x3;
7350       tep->reserved1 = (tmp1 >> 26) & 0x1;
7351       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7352       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7353       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7354       tep->Args_stored = (tmp1 >> 15) & 0x1;
7355       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7356       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7357       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7358       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7359       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7360       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7361       tep->cxx_info = (tmp1 >> 8) & 0x1;
7362       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7363       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7364       tep->reserved2 = (tmp1 >> 5) & 0x1;
7365       tep->Save_SP = (tmp1 >> 4) & 0x1;
7366       tep->Save_RP = (tmp1 >> 3) & 0x1;
7367       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7368       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7369       tep->Cleanup_defined = tmp1 & 0x1;
7370
7371       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7372       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7373       tep->Large_frame = (tmp2 >> 29) & 0x1;
7374       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7375       tep->reserved4 = (tmp2 >> 27) & 0x1;
7376       tep->Total_frame_size = tmp2 & 0x7ffffff;
7377     }
7378   free (table);
7379
7380   /* Third, apply any relocations to the unwind table.  */
7381   for (relsec = section_headers;
7382        relsec < section_headers + elf_header.e_shnum;
7383        ++relsec)
7384     {
7385       if (relsec->sh_type != SHT_RELA
7386           || relsec->sh_info >= elf_header.e_shnum
7387           || section_headers + relsec->sh_info != sec)
7388         continue;
7389
7390       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7391                               & rela, & nrelas))
7392         return 0;
7393
7394       for (rp = rela; rp < rela + nrelas; ++rp)
7395         {
7396           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7397           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7398
7399           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7400           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7401             {
7402               warn (_("Skipping unexpected relocation type %s\n"), relname);
7403               continue;
7404             }
7405
7406           i = rp->r_offset / unw_ent_size;
7407
7408           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7409             {
7410             case 0:
7411               aux->table[i].start.section = sym->st_shndx;
7412               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7413               break;
7414             case 1:
7415               aux->table[i].end.section   = sym->st_shndx;
7416               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7417               break;
7418             default:
7419               break;
7420             }
7421         }
7422
7423       free (rela);
7424     }
7425
7426   aux->table_len = nentries;
7427
7428   return 1;
7429 }
7430
7431 static void
7432 hppa_process_unwind (FILE * file)
7433 {
7434   struct hppa_unw_aux_info aux;
7435   Elf_Internal_Shdr * unwsec = NULL;
7436   Elf_Internal_Shdr * strsec;
7437   Elf_Internal_Shdr * sec;
7438   unsigned long i;
7439
7440   if (string_table == NULL)
7441     return;
7442
7443   memset (& aux, 0, sizeof (aux));
7444
7445   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7446     {
7447       if (sec->sh_type == SHT_SYMTAB
7448           && sec->sh_link < elf_header.e_shnum)
7449         {
7450           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7451
7452           strsec = section_headers + sec->sh_link;
7453           if (aux.strtab != NULL)
7454             {
7455               error (_("Multiple auxillary string tables encountered\n"));
7456               free (aux.strtab);
7457             }
7458           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7459                                           1, strsec->sh_size,
7460                                           _("string table"));
7461           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7462         }
7463       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7464         unwsec = sec;
7465     }
7466
7467   if (!unwsec)
7468     printf (_("\nThere are no unwind sections in this file.\n"));
7469
7470   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7471     {
7472       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7473         {
7474           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7475                   printable_section_name (sec),
7476                   (unsigned long) sec->sh_offset,
7477                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7478
7479           slurp_hppa_unwind_table (file, &aux, sec);
7480           if (aux.table_len > 0)
7481             dump_hppa_unwind (&aux);
7482
7483           if (aux.table)
7484             free ((char *) aux.table);
7485           aux.table = NULL;
7486         }
7487     }
7488
7489   if (aux.symtab)
7490     free (aux.symtab);
7491   if (aux.strtab)
7492     free ((char *) aux.strtab);
7493 }
7494
7495 struct arm_section
7496 {
7497   unsigned char *      data;            /* The unwind data.  */
7498   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7499   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7500   unsigned long        nrelas;          /* The number of relocations.  */
7501   unsigned int         rel_type;        /* REL or RELA ?  */
7502   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7503 };
7504
7505 struct arm_unw_aux_info
7506 {
7507   FILE *              file;             /* The file containing the unwind sections.  */
7508   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7509   unsigned long       nsyms;            /* Number of symbols.  */
7510   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7511   unsigned long       nfuns;            /* Number of these symbols.  */
7512   char *              strtab;           /* The file's string table.  */
7513   unsigned long       strtab_size;      /* Size of string table.  */
7514 };
7515
7516 static const char *
7517 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7518                         bfd_vma fn, struct absaddr addr)
7519 {
7520   const char *procname;
7521   bfd_vma sym_offset;
7522
7523   if (addr.section == SHN_UNDEF)
7524     addr.offset = fn;
7525
7526   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7527                            aux->strtab_size, addr, &procname,
7528                            &sym_offset);
7529
7530   print_vma (fn, PREFIX_HEX);
7531
7532   if (procname)
7533     {
7534       fputs (" <", stdout);
7535       fputs (procname, stdout);
7536
7537       if (sym_offset)
7538         printf ("+0x%lx", (unsigned long) sym_offset);
7539       fputc ('>', stdout);
7540     }
7541
7542   return procname;
7543 }
7544
7545 static void
7546 arm_free_section (struct arm_section *arm_sec)
7547 {
7548   if (arm_sec->data != NULL)
7549     free (arm_sec->data);
7550
7551   if (arm_sec->rela != NULL)
7552     free (arm_sec->rela);
7553 }
7554
7555 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7556       cached section and install SEC instead.
7557    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7558       and return its valued in * WORDP, relocating if necessary.
7559    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7560       relocation's offset in ADDR.
7561    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7562       into the string table of the symbol associated with the reloc.  If no
7563       reloc was applied store -1 there.
7564    5) Return TRUE upon success, FALSE otherwise.  */
7565
7566 static bfd_boolean
7567 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7568                          struct arm_section *       arm_sec,
7569                          Elf_Internal_Shdr *        sec,
7570                          bfd_vma                    word_offset,
7571                          unsigned int *             wordp,
7572                          struct absaddr *           addr,
7573                          bfd_vma *                  sym_name)
7574 {
7575   Elf_Internal_Rela *rp;
7576   Elf_Internal_Sym *sym;
7577   const char * relname;
7578   unsigned int word;
7579   bfd_boolean wrapped;
7580
7581   if (sec == NULL || arm_sec == NULL)
7582     return FALSE;
7583
7584   addr->section = SHN_UNDEF;
7585   addr->offset = 0;
7586
7587   if (sym_name != NULL)
7588     *sym_name = (bfd_vma) -1;
7589
7590   /* If necessary, update the section cache.  */
7591   if (sec != arm_sec->sec)
7592     {
7593       Elf_Internal_Shdr *relsec;
7594
7595       arm_free_section (arm_sec);
7596
7597       arm_sec->sec = sec;
7598       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7599                                 sec->sh_size, _("unwind data"));
7600       arm_sec->rela = NULL;
7601       arm_sec->nrelas = 0;
7602
7603       for (relsec = section_headers;
7604            relsec < section_headers + elf_header.e_shnum;
7605            ++relsec)
7606         {
7607           if (relsec->sh_info >= elf_header.e_shnum
7608               || section_headers + relsec->sh_info != sec
7609               /* PR 15745: Check the section type as well.  */
7610               || (relsec->sh_type != SHT_REL
7611                   && relsec->sh_type != SHT_RELA))
7612             continue;
7613
7614           arm_sec->rel_type = relsec->sh_type;
7615           if (relsec->sh_type == SHT_REL)
7616             {
7617               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7618                                      relsec->sh_size,
7619                                      & arm_sec->rela, & arm_sec->nrelas))
7620                 return FALSE;
7621             }
7622           else /* relsec->sh_type == SHT_RELA */
7623             {
7624               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7625                                       relsec->sh_size,
7626                                       & arm_sec->rela, & arm_sec->nrelas))
7627                 return FALSE;
7628             }
7629           break;
7630         }
7631
7632       arm_sec->next_rela = arm_sec->rela;
7633     }
7634
7635   /* If there is no unwind data we can do nothing.  */
7636   if (arm_sec->data == NULL)
7637     return FALSE;
7638
7639   /* If the offset is invalid then fail.  */
7640   if (word_offset > (sec->sh_size - 4)
7641       /* PR 18879 */
7642       || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7643       || ((bfd_signed_vma) word_offset) < 0)
7644     return FALSE;
7645
7646   /* Get the word at the required offset.  */
7647   word = byte_get (arm_sec->data + word_offset, 4);
7648
7649   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7650   if (arm_sec->rela == NULL)
7651     {
7652       * wordp = word;
7653       return TRUE;
7654     }
7655
7656   /* Look through the relocs to find the one that applies to the provided offset.  */
7657   wrapped = FALSE;
7658   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7659     {
7660       bfd_vma prelval, offset;
7661
7662       if (rp->r_offset > word_offset && !wrapped)
7663         {
7664           rp = arm_sec->rela;
7665           wrapped = TRUE;
7666         }
7667       if (rp->r_offset > word_offset)
7668         break;
7669
7670       if (rp->r_offset & 3)
7671         {
7672           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7673                 (unsigned long) rp->r_offset);
7674           continue;
7675         }
7676
7677       if (rp->r_offset < word_offset)
7678         continue;
7679
7680       /* PR 17531: file: 027-161405-0.004  */
7681       if (aux->symtab == NULL)
7682         continue;
7683
7684       if (arm_sec->rel_type == SHT_REL)
7685         {
7686           offset = word & 0x7fffffff;
7687           if (offset & 0x40000000)
7688             offset |= ~ (bfd_vma) 0x7fffffff;
7689         }
7690       else if (arm_sec->rel_type == SHT_RELA)
7691         offset = rp->r_addend;
7692       else
7693         {
7694           error (_("Unknown section relocation type %d encountered\n"),
7695                  arm_sec->rel_type);
7696           break;
7697         }
7698
7699       /* PR 17531 file: 027-1241568-0.004.  */
7700       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7701         {
7702           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7703                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7704           break;
7705         }
7706
7707       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7708       offset += sym->st_value;
7709       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7710
7711       /* Check that we are processing the expected reloc type.  */
7712       if (elf_header.e_machine == EM_ARM)
7713         {
7714           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7715           if (relname == NULL)
7716             {
7717               warn (_("Skipping unknown ARM relocation type: %d\n"),
7718                     (int) ELF32_R_TYPE (rp->r_info));
7719               continue;
7720             }
7721
7722           if (streq (relname, "R_ARM_NONE"))
7723               continue;
7724
7725           if (! streq (relname, "R_ARM_PREL31"))
7726             {
7727               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7728               continue;
7729             }
7730         }
7731       else if (elf_header.e_machine == EM_TI_C6000)
7732         {
7733           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7734           if (relname == NULL)
7735             {
7736               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7737                     (int) ELF32_R_TYPE (rp->r_info));
7738               continue;
7739             }
7740
7741           if (streq (relname, "R_C6000_NONE"))
7742             continue;
7743
7744           if (! streq (relname, "R_C6000_PREL31"))
7745             {
7746               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7747               continue;
7748             }
7749
7750           prelval >>= 1;
7751         }
7752       else
7753         {
7754           /* This function currently only supports ARM and TI unwinders.  */
7755           warn (_("Only TI and ARM unwinders are currently supported\n"));
7756           break;
7757         }
7758
7759       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7760       addr->section = sym->st_shndx;
7761       addr->offset = offset;
7762
7763       if (sym_name)
7764         * sym_name = sym->st_name;
7765       break;
7766     }
7767
7768   *wordp = word;
7769   arm_sec->next_rela = rp;
7770
7771   return TRUE;
7772 }
7773
7774 static const char *tic6x_unwind_regnames[16] =
7775 {
7776   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7777   "A14", "A13", "A12", "A11", "A10",
7778   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7779 };
7780
7781 static void
7782 decode_tic6x_unwind_regmask (unsigned int mask)
7783 {
7784   int i;
7785
7786   for (i = 12; mask; mask >>= 1, i--)
7787     {
7788       if (mask & 1)
7789         {
7790           fputs (tic6x_unwind_regnames[i], stdout);
7791           if (mask > 1)
7792             fputs (", ", stdout);
7793         }
7794     }
7795 }
7796
7797 #define ADVANCE                                                 \
7798   if (remaining == 0 && more_words)                             \
7799     {                                                           \
7800       data_offset += 4;                                         \
7801       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7802                                      data_offset, & word, & addr, NULL))        \
7803         return;                                                 \
7804       remaining = 4;                                            \
7805       more_words--;                                             \
7806     }                                                           \
7807
7808 #define GET_OP(OP)                      \
7809   ADVANCE;                              \
7810   if (remaining)                        \
7811     {                                   \
7812       remaining--;                      \
7813       (OP) = word >> 24;                \
7814       word <<= 8;                       \
7815     }                                   \
7816   else                                  \
7817     {                                   \
7818       printf (_("[Truncated opcode]\n"));       \
7819       return;                           \
7820     }                                   \
7821   printf ("0x%02x ", OP)
7822
7823 static void
7824 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7825                             unsigned int               word,
7826                             unsigned int               remaining,
7827                             unsigned int               more_words,
7828                             bfd_vma                    data_offset,
7829                             Elf_Internal_Shdr *        data_sec,
7830                             struct arm_section *       data_arm_sec)
7831 {
7832   struct absaddr addr;
7833
7834   /* Decode the unwinding instructions.  */
7835   while (1)
7836     {
7837       unsigned int op, op2;
7838
7839       ADVANCE;
7840       if (remaining == 0)
7841         break;
7842       remaining--;
7843       op = word >> 24;
7844       word <<= 8;
7845
7846       printf ("  0x%02x ", op);
7847
7848       if ((op & 0xc0) == 0x00)
7849         {
7850           int offset = ((op & 0x3f) << 2) + 4;
7851
7852           printf ("     vsp = vsp + %d", offset);
7853         }
7854       else if ((op & 0xc0) == 0x40)
7855         {
7856           int offset = ((op & 0x3f) << 2) + 4;
7857
7858           printf ("     vsp = vsp - %d", offset);
7859         }
7860       else if ((op & 0xf0) == 0x80)
7861         {
7862           GET_OP (op2);
7863           if (op == 0x80 && op2 == 0)
7864             printf (_("Refuse to unwind"));
7865           else
7866             {
7867               unsigned int mask = ((op & 0x0f) << 8) | op2;
7868               int first = 1;
7869               int i;
7870
7871               printf ("pop {");
7872               for (i = 0; i < 12; i++)
7873                 if (mask & (1 << i))
7874                   {
7875                     if (first)
7876                       first = 0;
7877                     else
7878                       printf (", ");
7879                     printf ("r%d", 4 + i);
7880                   }
7881               printf ("}");
7882             }
7883         }
7884       else if ((op & 0xf0) == 0x90)
7885         {
7886           if (op == 0x9d || op == 0x9f)
7887             printf (_("     [Reserved]"));
7888           else
7889             printf ("     vsp = r%d", op & 0x0f);
7890         }
7891       else if ((op & 0xf0) == 0xa0)
7892         {
7893           int end = 4 + (op & 0x07);
7894           int first = 1;
7895           int i;
7896
7897           printf ("     pop {");
7898           for (i = 4; i <= end; i++)
7899             {
7900               if (first)
7901                 first = 0;
7902               else
7903                 printf (", ");
7904               printf ("r%d", i);
7905             }
7906           if (op & 0x08)
7907             {
7908               if (!first)
7909                 printf (", ");
7910               printf ("r14");
7911             }
7912           printf ("}");
7913         }
7914       else if (op == 0xb0)
7915         printf (_("     finish"));
7916       else if (op == 0xb1)
7917         {
7918           GET_OP (op2);
7919           if (op2 == 0 || (op2 & 0xf0) != 0)
7920             printf (_("[Spare]"));
7921           else
7922             {
7923               unsigned int mask = op2 & 0x0f;
7924               int first = 1;
7925               int i;
7926
7927               printf ("pop {");
7928               for (i = 0; i < 12; i++)
7929                 if (mask & (1 << i))
7930                   {
7931                     if (first)
7932                       first = 0;
7933                     else
7934                       printf (", ");
7935                     printf ("r%d", i);
7936                   }
7937               printf ("}");
7938             }
7939         }
7940       else if (op == 0xb2)
7941         {
7942           unsigned char buf[9];
7943           unsigned int i, len;
7944           unsigned long offset;
7945
7946           for (i = 0; i < sizeof (buf); i++)
7947             {
7948               GET_OP (buf[i]);
7949               if ((buf[i] & 0x80) == 0)
7950                 break;
7951             }
7952           if (i == sizeof (buf))
7953             printf (_("corrupt change to vsp"));
7954           else
7955             {
7956               offset = read_uleb128 (buf, &len, buf + i + 1);
7957               assert (len == i + 1);
7958               offset = offset * 4 + 0x204;
7959               printf ("vsp = vsp + %ld", offset);
7960             }
7961         }
7962       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7963         {
7964           unsigned int first, last;
7965
7966           GET_OP (op2);
7967           first = op2 >> 4;
7968           last = op2 & 0x0f;
7969           if (op == 0xc8)
7970             first = first + 16;
7971           printf ("pop {D%d", first);
7972           if (last)
7973             printf ("-D%d", first + last);
7974           printf ("}");
7975         }
7976       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7977         {
7978           unsigned int count = op & 0x07;
7979
7980           printf ("pop {D8");
7981           if (count)
7982             printf ("-D%d", 8 + count);
7983           printf ("}");
7984         }
7985       else if (op >= 0xc0 && op <= 0xc5)
7986         {
7987           unsigned int count = op & 0x07;
7988
7989           printf ("     pop {wR10");
7990           if (count)
7991             printf ("-wR%d", 10 + count);
7992           printf ("}");
7993         }
7994       else if (op == 0xc6)
7995         {
7996           unsigned int first, last;
7997
7998           GET_OP (op2);
7999           first = op2 >> 4;
8000           last = op2 & 0x0f;
8001           printf ("pop {wR%d", first);
8002           if (last)
8003             printf ("-wR%d", first + last);
8004           printf ("}");
8005         }
8006       else if (op == 0xc7)
8007         {
8008           GET_OP (op2);
8009           if (op2 == 0 || (op2 & 0xf0) != 0)
8010             printf (_("[Spare]"));
8011           else
8012             {
8013               unsigned int mask = op2 & 0x0f;
8014               int first = 1;
8015               int i;
8016
8017               printf ("pop {");
8018               for (i = 0; i < 4; i++)
8019                 if (mask & (1 << i))
8020                   {
8021                     if (first)
8022                       first = 0;
8023                     else
8024                       printf (", ");
8025                     printf ("wCGR%d", i);
8026                   }
8027               printf ("}");
8028             }
8029         }
8030       else
8031         printf (_("     [unsupported opcode]"));
8032       printf ("\n");
8033     }
8034 }
8035
8036 static void
8037 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8038                               unsigned int               word,
8039                               unsigned int               remaining,
8040                               unsigned int               more_words,
8041                               bfd_vma                    data_offset,
8042                               Elf_Internal_Shdr *        data_sec,
8043                               struct arm_section *       data_arm_sec)
8044 {
8045   struct absaddr addr;
8046
8047   /* Decode the unwinding instructions.  */
8048   while (1)
8049     {
8050       unsigned int op, op2;
8051
8052       ADVANCE;
8053       if (remaining == 0)
8054         break;
8055       remaining--;
8056       op = word >> 24;
8057       word <<= 8;
8058
8059       printf ("  0x%02x ", op);
8060
8061       if ((op & 0xc0) == 0x00)
8062         {
8063           int offset = ((op & 0x3f) << 3) + 8;
8064           printf ("     sp = sp + %d", offset);
8065         }
8066       else if ((op & 0xc0) == 0x80)
8067         {
8068           GET_OP (op2);
8069           if (op == 0x80 && op2 == 0)
8070             printf (_("Refuse to unwind"));
8071           else
8072             {
8073               unsigned int mask = ((op & 0x1f) << 8) | op2;
8074               if (op & 0x20)
8075                 printf ("pop compact {");
8076               else
8077                 printf ("pop {");
8078
8079               decode_tic6x_unwind_regmask (mask);
8080               printf("}");
8081             }
8082         }
8083       else if ((op & 0xf0) == 0xc0)
8084         {
8085           unsigned int reg;
8086           unsigned int nregs;
8087           unsigned int i;
8088           const char *name;
8089           struct
8090           {
8091               unsigned int offset;
8092               unsigned int reg;
8093           } regpos[16];
8094
8095           /* Scan entire instruction first so that GET_OP output is not
8096              interleaved with disassembly.  */
8097           nregs = 0;
8098           for (i = 0; nregs < (op & 0xf); i++)
8099             {
8100               GET_OP (op2);
8101               reg = op2 >> 4;
8102               if (reg != 0xf)
8103                 {
8104                   regpos[nregs].offset = i * 2;
8105                   regpos[nregs].reg = reg;
8106                   nregs++;
8107                 }
8108
8109               reg = op2 & 0xf;
8110               if (reg != 0xf)
8111                 {
8112                   regpos[nregs].offset = i * 2 + 1;
8113                   regpos[nregs].reg = reg;
8114                   nregs++;
8115                 }
8116             }
8117
8118           printf (_("pop frame {"));
8119           reg = nregs - 1;
8120           for (i = i * 2; i > 0; i--)
8121             {
8122               if (regpos[reg].offset == i - 1)
8123                 {
8124                   name = tic6x_unwind_regnames[regpos[reg].reg];
8125                   if (reg > 0)
8126                     reg--;
8127                 }
8128               else
8129                 name = _("[pad]");
8130
8131               fputs (name, stdout);
8132               if (i > 1)
8133                 printf (", ");
8134             }
8135
8136           printf ("}");
8137         }
8138       else if (op == 0xd0)
8139         printf ("     MOV FP, SP");
8140       else if (op == 0xd1)
8141         printf ("     __c6xabi_pop_rts");
8142       else if (op == 0xd2)
8143         {
8144           unsigned char buf[9];
8145           unsigned int i, len;
8146           unsigned long offset;
8147
8148           for (i = 0; i < sizeof (buf); i++)
8149             {
8150               GET_OP (buf[i]);
8151               if ((buf[i] & 0x80) == 0)
8152                 break;
8153             }
8154           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8155           if (i == sizeof (buf))
8156             {
8157               printf ("<corrupt sp adjust>\n");
8158               warn (_("Corrupt stack pointer adjustment detected\n"));
8159               return;
8160             }
8161
8162           offset = read_uleb128 (buf, &len, buf + i + 1);
8163           assert (len == i + 1);
8164           offset = offset * 8 + 0x408;
8165           printf (_("sp = sp + %ld"), offset);
8166         }
8167       else if ((op & 0xf0) == 0xe0)
8168         {
8169           if ((op & 0x0f) == 7)
8170             printf ("     RETURN");
8171           else
8172             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8173         }
8174       else
8175         {
8176           printf (_("     [unsupported opcode]"));
8177         }
8178       putchar ('\n');
8179     }
8180 }
8181
8182 static bfd_vma
8183 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8184 {
8185   bfd_vma offset;
8186
8187   offset = word & 0x7fffffff;
8188   if (offset & 0x40000000)
8189     offset |= ~ (bfd_vma) 0x7fffffff;
8190
8191   if (elf_header.e_machine == EM_TI_C6000)
8192     offset <<= 1;
8193
8194   return offset + where;
8195 }
8196
8197 static void
8198 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8199                    unsigned int               word,
8200                    unsigned int               remaining,
8201                    bfd_vma                    data_offset,
8202                    Elf_Internal_Shdr *        data_sec,
8203                    struct arm_section *       data_arm_sec)
8204 {
8205   int per_index;
8206   unsigned int more_words = 0;
8207   struct absaddr addr;
8208   bfd_vma sym_name = (bfd_vma) -1;
8209
8210   if (remaining == 0)
8211     {
8212       /* Fetch the first word.
8213          Note - when decoding an object file the address extracted
8214          here will always be 0.  So we also pass in the sym_name
8215          parameter so that we can find the symbol associated with
8216          the personality routine.  */
8217       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8218                                      & word, & addr, & sym_name))
8219         return;
8220
8221       remaining = 4;
8222     }
8223
8224   if ((word & 0x80000000) == 0)
8225     {
8226       /* Expand prel31 for personality routine.  */
8227       bfd_vma fn;
8228       const char *procname;
8229
8230       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8231       printf (_("  Personality routine: "));
8232       if (fn == 0
8233           && addr.section == SHN_UNDEF && addr.offset == 0
8234           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8235         {
8236           procname = aux->strtab + sym_name;
8237           print_vma (fn, PREFIX_HEX);
8238           if (procname)
8239             {
8240               fputs (" <", stdout);
8241               fputs (procname, stdout);
8242               fputc ('>', stdout);
8243             }
8244         }
8245       else
8246         procname = arm_print_vma_and_name (aux, fn, addr);
8247       fputc ('\n', stdout);
8248
8249       /* The GCC personality routines use the standard compact
8250          encoding, starting with one byte giving the number of
8251          words.  */
8252       if (procname != NULL
8253           && (const_strneq (procname, "__gcc_personality_v0")
8254               || const_strneq (procname, "__gxx_personality_v0")
8255               || const_strneq (procname, "__gcj_personality_v0")
8256               || const_strneq (procname, "__gnu_objc_personality_v0")))
8257         {
8258           remaining = 0;
8259           more_words = 1;
8260           ADVANCE;
8261           if (!remaining)
8262             {
8263               printf (_("  [Truncated data]\n"));
8264               return;
8265             }
8266           more_words = word >> 24;
8267           word <<= 8;
8268           remaining--;
8269           per_index = -1;
8270         }
8271       else
8272         return;
8273     }
8274   else
8275     {
8276       /* ARM EHABI Section 6.3:
8277
8278          An exception-handling table entry for the compact model looks like:
8279
8280            31 30-28 27-24 23-0
8281            -- ----- ----- ----
8282             1   0   index Data for personalityRoutine[index]    */
8283
8284       if (elf_header.e_machine == EM_ARM
8285           && (word & 0x70000000))
8286         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8287
8288       per_index = (word >> 24) & 0x7f;
8289       printf (_("  Compact model index: %d\n"), per_index);
8290       if (per_index == 0)
8291         {
8292           more_words = 0;
8293           word <<= 8;
8294           remaining--;
8295         }
8296       else if (per_index < 3)
8297         {
8298           more_words = (word >> 16) & 0xff;
8299           word <<= 16;
8300           remaining -= 2;
8301         }
8302     }
8303
8304   switch (elf_header.e_machine)
8305     {
8306     case EM_ARM:
8307       if (per_index < 3)
8308         {
8309           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8310                                       data_offset, data_sec, data_arm_sec);
8311         }
8312       else
8313         {
8314           warn (_("Unknown ARM compact model index encountered\n"));
8315           printf (_("  [reserved]\n"));
8316         }
8317       break;
8318
8319     case EM_TI_C6000:
8320       if (per_index < 3)
8321         {
8322           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8323                                         data_offset, data_sec, data_arm_sec);
8324         }
8325       else if (per_index < 5)
8326         {
8327           if (((word >> 17) & 0x7f) == 0x7f)
8328             printf (_("  Restore stack from frame pointer\n"));
8329           else
8330             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8331           printf (_("  Registers restored: "));
8332           if (per_index == 4)
8333             printf (" (compact) ");
8334           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8335           putchar ('\n');
8336           printf (_("  Return register: %s\n"),
8337                   tic6x_unwind_regnames[word & 0xf]);
8338         }
8339       else
8340         printf (_("  [reserved (%d)]\n"), per_index);
8341       break;
8342
8343     default:
8344       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8345              elf_header.e_machine);
8346     }
8347
8348   /* Decode the descriptors.  Not implemented.  */
8349 }
8350
8351 static void
8352 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8353 {
8354   struct arm_section exidx_arm_sec, extab_arm_sec;
8355   unsigned int i, exidx_len;
8356   unsigned long j, nfuns;
8357
8358   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8359   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8360   exidx_len = exidx_sec->sh_size / 8;
8361
8362   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8363   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8364     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8365       aux->funtab[nfuns++] = aux->symtab[j];
8366   aux->nfuns = nfuns;
8367   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8368
8369   for (i = 0; i < exidx_len; i++)
8370     {
8371       unsigned int exidx_fn, exidx_entry;
8372       struct absaddr fn_addr, entry_addr;
8373       bfd_vma fn;
8374
8375       fputc ('\n', stdout);
8376
8377       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8378                                      8 * i, & exidx_fn, & fn_addr, NULL)
8379           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8380                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8381         {
8382           free (aux->funtab);
8383           arm_free_section (& exidx_arm_sec);
8384           arm_free_section (& extab_arm_sec);
8385           return;
8386         }
8387
8388       /* ARM EHABI, Section 5:
8389          An index table entry consists of 2 words.
8390          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8391       if (exidx_fn & 0x80000000)
8392         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8393
8394       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8395
8396       arm_print_vma_and_name (aux, fn, fn_addr);
8397       fputs (": ", stdout);
8398
8399       if (exidx_entry == 1)
8400         {
8401           print_vma (exidx_entry, PREFIX_HEX);
8402           fputs (" [cantunwind]\n", stdout);
8403         }
8404       else if (exidx_entry & 0x80000000)
8405         {
8406           print_vma (exidx_entry, PREFIX_HEX);
8407           fputc ('\n', stdout);
8408           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8409         }
8410       else
8411         {
8412           bfd_vma table, table_offset = 0;
8413           Elf_Internal_Shdr *table_sec;
8414
8415           fputs ("@", stdout);
8416           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8417           print_vma (table, PREFIX_HEX);
8418           printf ("\n");
8419
8420           /* Locate the matching .ARM.extab.  */
8421           if (entry_addr.section != SHN_UNDEF
8422               && entry_addr.section < elf_header.e_shnum)
8423             {
8424               table_sec = section_headers + entry_addr.section;
8425               table_offset = entry_addr.offset;
8426               /* PR 18879 */
8427               if (table_offset > table_sec->sh_size
8428                   || ((bfd_signed_vma) table_offset) < 0)
8429                 {
8430                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8431                         (unsigned long) table_offset,
8432                         printable_section_name (table_sec));
8433                   continue;
8434                 }
8435             }
8436           else
8437             {
8438               table_sec = find_section_by_address (table);
8439               if (table_sec != NULL)
8440                 table_offset = table - table_sec->sh_addr;
8441             }
8442           if (table_sec == NULL)
8443             {
8444               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8445                     (unsigned long) table);
8446               continue;
8447             }
8448           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8449                              &extab_arm_sec);
8450         }
8451     }
8452
8453   printf ("\n");
8454
8455   free (aux->funtab);
8456   arm_free_section (&exidx_arm_sec);
8457   arm_free_section (&extab_arm_sec);
8458 }
8459
8460 /* Used for both ARM and C6X unwinding tables.  */
8461
8462 static void
8463 arm_process_unwind (FILE *file)
8464 {
8465   struct arm_unw_aux_info aux;
8466   Elf_Internal_Shdr *unwsec = NULL;
8467   Elf_Internal_Shdr *strsec;
8468   Elf_Internal_Shdr *sec;
8469   unsigned long i;
8470   unsigned int sec_type;
8471
8472   switch (elf_header.e_machine)
8473     {
8474     case EM_ARM:
8475       sec_type = SHT_ARM_EXIDX;
8476       break;
8477
8478     case EM_TI_C6000:
8479       sec_type = SHT_C6000_UNWIND;
8480       break;
8481
8482     default:
8483       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8484              elf_header.e_machine);
8485       return;
8486     }
8487
8488   if (string_table == NULL)
8489     return;
8490
8491   memset (& aux, 0, sizeof (aux));
8492   aux.file = file;
8493
8494   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8495     {
8496       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8497         {
8498           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8499
8500           strsec = section_headers + sec->sh_link;
8501
8502           /* PR binutils/17531 file: 011-12666-0.004.  */
8503           if (aux.strtab != NULL)
8504             {
8505               error (_("Multiple string tables found in file.\n"));
8506               free (aux.strtab);
8507             }
8508           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8509                                  1, strsec->sh_size, _("string table"));
8510           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8511         }
8512       else if (sec->sh_type == sec_type)
8513         unwsec = sec;
8514     }
8515
8516   if (unwsec == NULL)
8517     printf (_("\nThere are no unwind sections in this file.\n"));
8518   else
8519     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8520       {
8521         if (sec->sh_type == sec_type)
8522           {
8523             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8524                     printable_section_name (sec),
8525                     (unsigned long) sec->sh_offset,
8526                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8527
8528             dump_arm_unwind (&aux, sec);
8529           }
8530       }
8531
8532   if (aux.symtab)
8533     free (aux.symtab);
8534   if (aux.strtab)
8535     free ((char *) aux.strtab);
8536 }
8537
8538 static void
8539 process_unwind (FILE * file)
8540 {
8541   struct unwind_handler
8542   {
8543     int machtype;
8544     void (* handler)(FILE *);
8545   } handlers[] =
8546   {
8547     { EM_ARM, arm_process_unwind },
8548     { EM_IA_64, ia64_process_unwind },
8549     { EM_PARISC, hppa_process_unwind },
8550     { EM_TI_C6000, arm_process_unwind },
8551     { 0, 0 }
8552   };
8553   int i;
8554
8555   if (!do_unwind)
8556     return;
8557
8558   for (i = 0; handlers[i].handler != NULL; i++)
8559     if (elf_header.e_machine == handlers[i].machtype)
8560       {
8561         handlers[i].handler (file);
8562         return;
8563       }
8564
8565   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8566           get_machine_name (elf_header.e_machine));
8567 }
8568
8569 static void
8570 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8571 {
8572   switch (entry->d_tag)
8573     {
8574     case DT_MIPS_FLAGS:
8575       if (entry->d_un.d_val == 0)
8576         printf (_("NONE"));
8577       else
8578         {
8579           static const char * opts[] =
8580           {
8581             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8582             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8583             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8584             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8585             "RLD_ORDER_SAFE"
8586           };
8587           unsigned int cnt;
8588           int first = 1;
8589
8590           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8591             if (entry->d_un.d_val & (1 << cnt))
8592               {
8593                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8594                 first = 0;
8595               }
8596         }
8597       break;
8598
8599     case DT_MIPS_IVERSION:
8600       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8601         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8602       else
8603         {
8604           char buf[40];
8605           sprintf_vma (buf, entry->d_un.d_ptr);
8606           /* Note: coded this way so that there is a single string for translation.  */
8607           printf (_("<corrupt: %s>"), buf);
8608         }
8609       break;
8610
8611     case DT_MIPS_TIME_STAMP:
8612       {
8613         char timebuf[20];
8614         struct tm * tmp;
8615         time_t atime = entry->d_un.d_val;
8616
8617         tmp = gmtime (&atime);
8618         /* PR 17531: file: 6accc532.  */
8619         if (tmp == NULL)
8620           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8621         else
8622           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8623                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8624                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8625         printf (_("Time Stamp: %s"), timebuf);
8626       }
8627       break;
8628
8629     case DT_MIPS_RLD_VERSION:
8630     case DT_MIPS_LOCAL_GOTNO:
8631     case DT_MIPS_CONFLICTNO:
8632     case DT_MIPS_LIBLISTNO:
8633     case DT_MIPS_SYMTABNO:
8634     case DT_MIPS_UNREFEXTNO:
8635     case DT_MIPS_HIPAGENO:
8636     case DT_MIPS_DELTA_CLASS_NO:
8637     case DT_MIPS_DELTA_INSTANCE_NO:
8638     case DT_MIPS_DELTA_RELOC_NO:
8639     case DT_MIPS_DELTA_SYM_NO:
8640     case DT_MIPS_DELTA_CLASSSYM_NO:
8641     case DT_MIPS_COMPACT_SIZE:
8642       print_vma (entry->d_un.d_ptr, DEC);
8643       break;
8644
8645     default:
8646       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8647     }
8648     putchar ('\n');
8649 }
8650
8651 static void
8652 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8653 {
8654   switch (entry->d_tag)
8655     {
8656     case DT_HP_DLD_FLAGS:
8657       {
8658         static struct
8659         {
8660           long int bit;
8661           const char * str;
8662         }
8663         flags[] =
8664         {
8665           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8666           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8667           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8668           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8669           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8670           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8671           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8672           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8673           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8674           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8675           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8676           { DT_HP_GST, "HP_GST" },
8677           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8678           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8679           { DT_HP_NODELETE, "HP_NODELETE" },
8680           { DT_HP_GROUP, "HP_GROUP" },
8681           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8682         };
8683         int first = 1;
8684         size_t cnt;
8685         bfd_vma val = entry->d_un.d_val;
8686
8687         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8688           if (val & flags[cnt].bit)
8689             {
8690               if (! first)
8691                 putchar (' ');
8692               fputs (flags[cnt].str, stdout);
8693               first = 0;
8694               val ^= flags[cnt].bit;
8695             }
8696
8697         if (val != 0 || first)
8698           {
8699             if (! first)
8700               putchar (' ');
8701             print_vma (val, HEX);
8702           }
8703       }
8704       break;
8705
8706     default:
8707       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8708       break;
8709     }
8710   putchar ('\n');
8711 }
8712
8713 #ifdef BFD64
8714
8715 /* VMS vs Unix time offset and factor.  */
8716
8717 #define VMS_EPOCH_OFFSET 35067168000000000LL
8718 #define VMS_GRANULARITY_FACTOR 10000000
8719
8720 /* Display a VMS time in a human readable format.  */
8721
8722 static void
8723 print_vms_time (bfd_int64_t vmstime)
8724 {
8725   struct tm *tm;
8726   time_t unxtime;
8727
8728   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8729   tm = gmtime (&unxtime);
8730   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8731           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8732           tm->tm_hour, tm->tm_min, tm->tm_sec);
8733 }
8734 #endif /* BFD64 */
8735
8736 static void
8737 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8738 {
8739   switch (entry->d_tag)
8740     {
8741     case DT_IA_64_PLT_RESERVE:
8742       /* First 3 slots reserved.  */
8743       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8744       printf (" -- ");
8745       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8746       break;
8747
8748     case DT_IA_64_VMS_LINKTIME:
8749 #ifdef BFD64
8750       print_vms_time (entry->d_un.d_val);
8751 #endif
8752       break;
8753
8754     case DT_IA_64_VMS_LNKFLAGS:
8755       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8756       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8757         printf (" CALL_DEBUG");
8758       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8759         printf (" NOP0BUFS");
8760       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8761         printf (" P0IMAGE");
8762       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8763         printf (" MKTHREADS");
8764       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8765         printf (" UPCALLS");
8766       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8767         printf (" IMGSTA");
8768       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8769         printf (" INITIALIZE");
8770       if (entry->d_un.d_val & VMS_LF_MAIN)
8771         printf (" MAIN");
8772       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8773         printf (" EXE_INIT");
8774       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8775         printf (" TBK_IN_IMG");
8776       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8777         printf (" DBG_IN_IMG");
8778       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8779         printf (" TBK_IN_DSF");
8780       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8781         printf (" DBG_IN_DSF");
8782       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8783         printf (" SIGNATURES");
8784       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8785         printf (" REL_SEG_OFF");
8786       break;
8787
8788     default:
8789       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8790       break;
8791     }
8792   putchar ('\n');
8793 }
8794
8795 static int
8796 get_32bit_dynamic_section (FILE * file)
8797 {
8798   Elf32_External_Dyn * edyn;
8799   Elf32_External_Dyn * ext;
8800   Elf_Internal_Dyn * entry;
8801
8802   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8803                                           dynamic_size, _("dynamic section"));
8804   if (!edyn)
8805     return 0;
8806
8807   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8808      might not have the luxury of section headers.  Look for the DT_NULL
8809      terminator to determine the number of entries.  */
8810   for (ext = edyn, dynamic_nent = 0;
8811        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8812        ext++)
8813     {
8814       dynamic_nent++;
8815       if (BYTE_GET (ext->d_tag) == DT_NULL)
8816         break;
8817     }
8818
8819   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8820                                                   sizeof (* entry));
8821   if (dynamic_section == NULL)
8822     {
8823       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8824              (unsigned long) dynamic_nent);
8825       free (edyn);
8826       return 0;
8827     }
8828
8829   for (ext = edyn, entry = dynamic_section;
8830        entry < dynamic_section + dynamic_nent;
8831        ext++, entry++)
8832     {
8833       entry->d_tag      = BYTE_GET (ext->d_tag);
8834       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8835     }
8836
8837   free (edyn);
8838
8839   return 1;
8840 }
8841
8842 static int
8843 get_64bit_dynamic_section (FILE * file)
8844 {
8845   Elf64_External_Dyn * edyn;
8846   Elf64_External_Dyn * ext;
8847   Elf_Internal_Dyn * entry;
8848
8849   /* Read in the data.  */
8850   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8851                                           dynamic_size, _("dynamic section"));
8852   if (!edyn)
8853     return 0;
8854
8855   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8856      might not have the luxury of section headers.  Look for the DT_NULL
8857      terminator to determine the number of entries.  */
8858   for (ext = edyn, dynamic_nent = 0;
8859        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
8860        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8861        ext++)
8862     {
8863       dynamic_nent++;
8864       if (BYTE_GET (ext->d_tag) == DT_NULL)
8865         break;
8866     }
8867
8868   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8869                                                   sizeof (* entry));
8870   if (dynamic_section == NULL)
8871     {
8872       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8873              (unsigned long) dynamic_nent);
8874       free (edyn);
8875       return 0;
8876     }
8877
8878   /* Convert from external to internal formats.  */
8879   for (ext = edyn, entry = dynamic_section;
8880        entry < dynamic_section + dynamic_nent;
8881        ext++, entry++)
8882     {
8883       entry->d_tag      = BYTE_GET (ext->d_tag);
8884       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8885     }
8886
8887   free (edyn);
8888
8889   return 1;
8890 }
8891
8892 static void
8893 print_dynamic_flags (bfd_vma flags)
8894 {
8895   int first = 1;
8896
8897   while (flags)
8898     {
8899       bfd_vma flag;
8900
8901       flag = flags & - flags;
8902       flags &= ~ flag;
8903
8904       if (first)
8905         first = 0;
8906       else
8907         putc (' ', stdout);
8908
8909       switch (flag)
8910         {
8911         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8912         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8913         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8914         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8915         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8916         default:                fputs (_("unknown"), stdout); break;
8917         }
8918     }
8919   puts ("");
8920 }
8921
8922 /* Parse and display the contents of the dynamic section.  */
8923
8924 static int
8925 process_dynamic_section (FILE * file)
8926 {
8927   Elf_Internal_Dyn * entry;
8928
8929   if (dynamic_size == 0)
8930     {
8931       if (do_dynamic)
8932         printf (_("\nThere is no dynamic section in this file.\n"));
8933
8934       return 1;
8935     }
8936
8937   if (is_32bit_elf)
8938     {
8939       if (! get_32bit_dynamic_section (file))
8940         return 0;
8941     }
8942   else if (! get_64bit_dynamic_section (file))
8943     return 0;
8944
8945   /* Find the appropriate symbol table.  */
8946   if (dynamic_symbols == NULL)
8947     {
8948       for (entry = dynamic_section;
8949            entry < dynamic_section + dynamic_nent;
8950            ++entry)
8951         {
8952           Elf_Internal_Shdr section;
8953
8954           if (entry->d_tag != DT_SYMTAB)
8955             continue;
8956
8957           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8958
8959           /* Since we do not know how big the symbol table is,
8960              we default to reading in the entire file (!) and
8961              processing that.  This is overkill, I know, but it
8962              should work.  */
8963           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8964
8965           if (archive_file_offset != 0)
8966             section.sh_size = archive_file_size - section.sh_offset;
8967           else
8968             {
8969               if (fseek (file, 0, SEEK_END))
8970                 error (_("Unable to seek to end of file!\n"));
8971
8972               section.sh_size = ftell (file) - section.sh_offset;
8973             }
8974
8975           if (is_32bit_elf)
8976             section.sh_entsize = sizeof (Elf32_External_Sym);
8977           else
8978             section.sh_entsize = sizeof (Elf64_External_Sym);
8979           section.sh_name = string_table_length;
8980
8981           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8982           if (num_dynamic_syms < 1)
8983             {
8984               error (_("Unable to determine the number of symbols to load\n"));
8985               continue;
8986             }
8987         }
8988     }
8989
8990   /* Similarly find a string table.  */
8991   if (dynamic_strings == NULL)
8992     {
8993       for (entry = dynamic_section;
8994            entry < dynamic_section + dynamic_nent;
8995            ++entry)
8996         {
8997           unsigned long offset;
8998           long str_tab_len;
8999
9000           if (entry->d_tag != DT_STRTAB)
9001             continue;
9002
9003           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9004
9005           /* Since we do not know how big the string table is,
9006              we default to reading in the entire file (!) and
9007              processing that.  This is overkill, I know, but it
9008              should work.  */
9009
9010           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9011
9012           if (archive_file_offset != 0)
9013             str_tab_len = archive_file_size - offset;
9014           else
9015             {
9016               if (fseek (file, 0, SEEK_END))
9017                 error (_("Unable to seek to end of file\n"));
9018               str_tab_len = ftell (file) - offset;
9019             }
9020
9021           if (str_tab_len < 1)
9022             {
9023               error
9024                 (_("Unable to determine the length of the dynamic string table\n"));
9025               continue;
9026             }
9027
9028           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9029                                                str_tab_len,
9030                                                _("dynamic string table"));
9031           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9032           break;
9033         }
9034     }
9035
9036   /* And find the syminfo section if available.  */
9037   if (dynamic_syminfo == NULL)
9038     {
9039       unsigned long syminsz = 0;
9040
9041       for (entry = dynamic_section;
9042            entry < dynamic_section + dynamic_nent;
9043            ++entry)
9044         {
9045           if (entry->d_tag == DT_SYMINENT)
9046             {
9047               /* Note: these braces are necessary to avoid a syntax
9048                  error from the SunOS4 C compiler.  */
9049               /* PR binutils/17531: A corrupt file can trigger this test.
9050                  So do not use an assert, instead generate an error message.  */
9051               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9052                 error (_("Bad value (%d) for SYMINENT entry\n"),
9053                        (int) entry->d_un.d_val);
9054             }
9055           else if (entry->d_tag == DT_SYMINSZ)
9056             syminsz = entry->d_un.d_val;
9057           else if (entry->d_tag == DT_SYMINFO)
9058             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9059                                                       syminsz);
9060         }
9061
9062       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9063         {
9064           Elf_External_Syminfo * extsyminfo;
9065           Elf_External_Syminfo * extsym;
9066           Elf_Internal_Syminfo * syminfo;
9067
9068           /* There is a syminfo section.  Read the data.  */
9069           extsyminfo = (Elf_External_Syminfo *)
9070               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9071                         _("symbol information"));
9072           if (!extsyminfo)
9073             return 0;
9074
9075           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9076           if (dynamic_syminfo == NULL)
9077             {
9078               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9079                      (unsigned long) syminsz);
9080               return 0;
9081             }
9082
9083           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9084           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9085                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9086                ++syminfo, ++extsym)
9087             {
9088               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9089               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9090             }
9091
9092           free (extsyminfo);
9093         }
9094     }
9095
9096   if (do_dynamic && dynamic_addr)
9097     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9098             dynamic_addr, (unsigned long) dynamic_nent);
9099   if (do_dynamic)
9100     printf (_("  Tag        Type                         Name/Value\n"));
9101
9102   for (entry = dynamic_section;
9103        entry < dynamic_section + dynamic_nent;
9104        entry++)
9105     {
9106       if (do_dynamic)
9107         {
9108           const char * dtype;
9109
9110           putchar (' ');
9111           print_vma (entry->d_tag, FULL_HEX);
9112           dtype = get_dynamic_type (entry->d_tag);
9113           printf (" (%s)%*s", dtype,
9114                   ((is_32bit_elf ? 27 : 19)
9115                    - (int) strlen (dtype)),
9116                   " ");
9117         }
9118
9119       switch (entry->d_tag)
9120         {
9121         case DT_FLAGS:
9122           if (do_dynamic)
9123             print_dynamic_flags (entry->d_un.d_val);
9124           break;
9125
9126         case DT_AUXILIARY:
9127         case DT_FILTER:
9128         case DT_CONFIG:
9129         case DT_DEPAUDIT:
9130         case DT_AUDIT:
9131           if (do_dynamic)
9132             {
9133               switch (entry->d_tag)
9134                 {
9135                 case DT_AUXILIARY:
9136                   printf (_("Auxiliary library"));
9137                   break;
9138
9139                 case DT_FILTER:
9140                   printf (_("Filter library"));
9141                   break;
9142
9143                 case DT_CONFIG:
9144                   printf (_("Configuration file"));
9145                   break;
9146
9147                 case DT_DEPAUDIT:
9148                   printf (_("Dependency audit library"));
9149                   break;
9150
9151                 case DT_AUDIT:
9152                   printf (_("Audit library"));
9153                   break;
9154                 }
9155
9156               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9157                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9158               else
9159                 {
9160                   printf (": ");
9161                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9162                   putchar ('\n');
9163                 }
9164             }
9165           break;
9166
9167         case DT_FEATURE:
9168           if (do_dynamic)
9169             {
9170               printf (_("Flags:"));
9171
9172               if (entry->d_un.d_val == 0)
9173                 printf (_(" None\n"));
9174               else
9175                 {
9176                   unsigned long int val = entry->d_un.d_val;
9177
9178                   if (val & DTF_1_PARINIT)
9179                     {
9180                       printf (" PARINIT");
9181                       val ^= DTF_1_PARINIT;
9182                     }
9183                   if (val & DTF_1_CONFEXP)
9184                     {
9185                       printf (" CONFEXP");
9186                       val ^= DTF_1_CONFEXP;
9187                     }
9188                   if (val != 0)
9189                     printf (" %lx", val);
9190                   puts ("");
9191                 }
9192             }
9193           break;
9194
9195         case DT_POSFLAG_1:
9196           if (do_dynamic)
9197             {
9198               printf (_("Flags:"));
9199
9200               if (entry->d_un.d_val == 0)
9201                 printf (_(" None\n"));
9202               else
9203                 {
9204                   unsigned long int val = entry->d_un.d_val;
9205
9206                   if (val & DF_P1_LAZYLOAD)
9207                     {
9208                       printf (" LAZYLOAD");
9209                       val ^= DF_P1_LAZYLOAD;
9210                     }
9211                   if (val & DF_P1_GROUPPERM)
9212                     {
9213                       printf (" GROUPPERM");
9214                       val ^= DF_P1_GROUPPERM;
9215                     }
9216                   if (val != 0)
9217                     printf (" %lx", val);
9218                   puts ("");
9219                 }
9220             }
9221           break;
9222
9223         case DT_FLAGS_1:
9224           if (do_dynamic)
9225             {
9226               printf (_("Flags:"));
9227               if (entry->d_un.d_val == 0)
9228                 printf (_(" None\n"));
9229               else
9230                 {
9231                   unsigned long int val = entry->d_un.d_val;
9232
9233                   if (val & DF_1_NOW)
9234                     {
9235                       printf (" NOW");
9236                       val ^= DF_1_NOW;
9237                     }
9238                   if (val & DF_1_GLOBAL)
9239                     {
9240                       printf (" GLOBAL");
9241                       val ^= DF_1_GLOBAL;
9242                     }
9243                   if (val & DF_1_GROUP)
9244                     {
9245                       printf (" GROUP");
9246                       val ^= DF_1_GROUP;
9247                     }
9248                   if (val & DF_1_NODELETE)
9249                     {
9250                       printf (" NODELETE");
9251                       val ^= DF_1_NODELETE;
9252                     }
9253                   if (val & DF_1_LOADFLTR)
9254                     {
9255                       printf (" LOADFLTR");
9256                       val ^= DF_1_LOADFLTR;
9257                     }
9258                   if (val & DF_1_INITFIRST)
9259                     {
9260                       printf (" INITFIRST");
9261                       val ^= DF_1_INITFIRST;
9262                     }
9263                   if (val & DF_1_NOOPEN)
9264                     {
9265                       printf (" NOOPEN");
9266                       val ^= DF_1_NOOPEN;
9267                     }
9268                   if (val & DF_1_ORIGIN)
9269                     {
9270                       printf (" ORIGIN");
9271                       val ^= DF_1_ORIGIN;
9272                     }
9273                   if (val & DF_1_DIRECT)
9274                     {
9275                       printf (" DIRECT");
9276                       val ^= DF_1_DIRECT;
9277                     }
9278                   if (val & DF_1_TRANS)
9279                     {
9280                       printf (" TRANS");
9281                       val ^= DF_1_TRANS;
9282                     }
9283                   if (val & DF_1_INTERPOSE)
9284                     {
9285                       printf (" INTERPOSE");
9286                       val ^= DF_1_INTERPOSE;
9287                     }
9288                   if (val & DF_1_NODEFLIB)
9289                     {
9290                       printf (" NODEFLIB");
9291                       val ^= DF_1_NODEFLIB;
9292                     }
9293                   if (val & DF_1_NODUMP)
9294                     {
9295                       printf (" NODUMP");
9296                       val ^= DF_1_NODUMP;
9297                     }
9298                   if (val & DF_1_CONFALT)
9299                     {
9300                       printf (" CONFALT");
9301                       val ^= DF_1_CONFALT;
9302                     }
9303                   if (val & DF_1_ENDFILTEE)
9304                     {
9305                       printf (" ENDFILTEE");
9306                       val ^= DF_1_ENDFILTEE;
9307                     }
9308                   if (val & DF_1_DISPRELDNE)
9309                     {
9310                       printf (" DISPRELDNE");
9311                       val ^= DF_1_DISPRELDNE;
9312                     }
9313                   if (val & DF_1_DISPRELPND)
9314                     {
9315                       printf (" DISPRELPND");
9316                       val ^= DF_1_DISPRELPND;
9317                     }
9318                   if (val & DF_1_NODIRECT)
9319                     {
9320                       printf (" NODIRECT");
9321                       val ^= DF_1_NODIRECT;
9322                     }
9323                   if (val & DF_1_IGNMULDEF)
9324                     {
9325                       printf (" IGNMULDEF");
9326                       val ^= DF_1_IGNMULDEF;
9327                     }
9328                   if (val & DF_1_NOKSYMS)
9329                     {
9330                       printf (" NOKSYMS");
9331                       val ^= DF_1_NOKSYMS;
9332                     }
9333                   if (val & DF_1_NOHDR)
9334                     {
9335                       printf (" NOHDR");
9336                       val ^= DF_1_NOHDR;
9337                     }
9338                   if (val & DF_1_EDITED)
9339                     {
9340                       printf (" EDITED");
9341                       val ^= DF_1_EDITED;
9342                     }
9343                   if (val & DF_1_NORELOC)
9344                     {
9345                       printf (" NORELOC");
9346                       val ^= DF_1_NORELOC;
9347                     }
9348                   if (val & DF_1_SYMINTPOSE)
9349                     {
9350                       printf (" SYMINTPOSE");
9351                       val ^= DF_1_SYMINTPOSE;
9352                     }
9353                   if (val & DF_1_GLOBAUDIT)
9354                     {
9355                       printf (" GLOBAUDIT");
9356                       val ^= DF_1_GLOBAUDIT;
9357                     }
9358                   if (val & DF_1_SINGLETON)
9359                     {
9360                       printf (" SINGLETON");
9361                       val ^= DF_1_SINGLETON;
9362                     }
9363                   if (val & DF_1_STUB)
9364                     {
9365                       printf (" STUB");
9366                       val ^= DF_1_STUB;
9367                     }
9368                   if (val & DF_1_PIE)
9369                     {
9370                       printf (" PIE");
9371                       val ^= DF_1_PIE;
9372                     }
9373                   if (val != 0)
9374                     printf (" %lx", val);
9375                   puts ("");
9376                 }
9377             }
9378           break;
9379
9380         case DT_PLTREL:
9381           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9382           if (do_dynamic)
9383             puts (get_dynamic_type (entry->d_un.d_val));
9384           break;
9385
9386         case DT_NULL    :
9387         case DT_NEEDED  :
9388         case DT_PLTGOT  :
9389         case DT_HASH    :
9390         case DT_STRTAB  :
9391         case DT_SYMTAB  :
9392         case DT_RELA    :
9393         case DT_INIT    :
9394         case DT_FINI    :
9395         case DT_SONAME  :
9396         case DT_RPATH   :
9397         case DT_SYMBOLIC:
9398         case DT_REL     :
9399         case DT_DEBUG   :
9400         case DT_TEXTREL :
9401         case DT_JMPREL  :
9402         case DT_RUNPATH :
9403           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9404
9405           if (do_dynamic)
9406             {
9407               char * name;
9408
9409               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9410                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9411               else
9412                 name = NULL;
9413
9414               if (name)
9415                 {
9416                   switch (entry->d_tag)
9417                     {
9418                     case DT_NEEDED:
9419                       printf (_("Shared library: [%s]"), name);
9420
9421                       if (streq (name, program_interpreter))
9422                         printf (_(" program interpreter"));
9423                       break;
9424
9425                     case DT_SONAME:
9426                       printf (_("Library soname: [%s]"), name);
9427                       break;
9428
9429                     case DT_RPATH:
9430                       printf (_("Library rpath: [%s]"), name);
9431                       break;
9432
9433                     case DT_RUNPATH:
9434                       printf (_("Library runpath: [%s]"), name);
9435                       break;
9436
9437                     default:
9438                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9439                       break;
9440                     }
9441                 }
9442               else
9443                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9444
9445               putchar ('\n');
9446             }
9447           break;
9448
9449         case DT_PLTRELSZ:
9450         case DT_RELASZ  :
9451         case DT_STRSZ   :
9452         case DT_RELSZ   :
9453         case DT_RELAENT :
9454         case DT_SYMENT  :
9455         case DT_RELENT  :
9456           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9457         case DT_PLTPADSZ:
9458         case DT_MOVEENT :
9459         case DT_MOVESZ  :
9460         case DT_INIT_ARRAYSZ:
9461         case DT_FINI_ARRAYSZ:
9462         case DT_GNU_CONFLICTSZ:
9463         case DT_GNU_LIBLISTSZ:
9464           if (do_dynamic)
9465             {
9466               print_vma (entry->d_un.d_val, UNSIGNED);
9467               printf (_(" (bytes)\n"));
9468             }
9469           break;
9470
9471         case DT_VERDEFNUM:
9472         case DT_VERNEEDNUM:
9473         case DT_RELACOUNT:
9474         case DT_RELCOUNT:
9475           if (do_dynamic)
9476             {
9477               print_vma (entry->d_un.d_val, UNSIGNED);
9478               putchar ('\n');
9479             }
9480           break;
9481
9482         case DT_SYMINSZ:
9483         case DT_SYMINENT:
9484         case DT_SYMINFO:
9485         case DT_USED:
9486         case DT_INIT_ARRAY:
9487         case DT_FINI_ARRAY:
9488           if (do_dynamic)
9489             {
9490               if (entry->d_tag == DT_USED
9491                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9492                 {
9493                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9494
9495                   if (*name)
9496                     {
9497                       printf (_("Not needed object: [%s]\n"), name);
9498                       break;
9499                     }
9500                 }
9501
9502               print_vma (entry->d_un.d_val, PREFIX_HEX);
9503               putchar ('\n');
9504             }
9505           break;
9506
9507         case DT_BIND_NOW:
9508           /* The value of this entry is ignored.  */
9509           if (do_dynamic)
9510             putchar ('\n');
9511           break;
9512
9513         case DT_GNU_PRELINKED:
9514           if (do_dynamic)
9515             {
9516               struct tm * tmp;
9517               time_t atime = entry->d_un.d_val;
9518
9519               tmp = gmtime (&atime);
9520               /* PR 17533 file: 041-1244816-0.004.  */
9521               if (tmp == NULL)
9522                 printf (_("<corrupt time val: %lx"),
9523                         (unsigned long) atime);
9524               else
9525                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9526                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9527                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9528
9529             }
9530           break;
9531
9532         case DT_GNU_HASH:
9533           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9534           if (do_dynamic)
9535             {
9536               print_vma (entry->d_un.d_val, PREFIX_HEX);
9537               putchar ('\n');
9538             }
9539           break;
9540
9541         default:
9542           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9543             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9544               entry->d_un.d_val;
9545
9546           if (do_dynamic)
9547             {
9548               switch (elf_header.e_machine)
9549                 {
9550                 case EM_MIPS:
9551                 case EM_MIPS_RS3_LE:
9552                   dynamic_section_mips_val (entry);
9553                   break;
9554                 case EM_PARISC:
9555                   dynamic_section_parisc_val (entry);
9556                   break;
9557                 case EM_IA_64:
9558                   dynamic_section_ia64_val (entry);
9559                   break;
9560                 default:
9561                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9562                   putchar ('\n');
9563                 }
9564             }
9565           break;
9566         }
9567     }
9568
9569   return 1;
9570 }
9571
9572 static char *
9573 get_ver_flags (unsigned int flags)
9574 {
9575   static char buff[32];
9576
9577   buff[0] = 0;
9578
9579   if (flags == 0)
9580     return _("none");
9581
9582   if (flags & VER_FLG_BASE)
9583     strcat (buff, "BASE ");
9584
9585   if (flags & VER_FLG_WEAK)
9586     {
9587       if (flags & VER_FLG_BASE)
9588         strcat (buff, "| ");
9589
9590       strcat (buff, "WEAK ");
9591     }
9592
9593   if (flags & VER_FLG_INFO)
9594     {
9595       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9596         strcat (buff, "| ");
9597
9598       strcat (buff, "INFO ");
9599     }
9600
9601   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9602     strcat (buff, _("| <unknown>"));
9603
9604   return buff;
9605 }
9606
9607 /* Display the contents of the version sections.  */
9608
9609 static int
9610 process_version_sections (FILE * file)
9611 {
9612   Elf_Internal_Shdr * section;
9613   unsigned i;
9614   int found = 0;
9615
9616   if (! do_version)
9617     return 1;
9618
9619   for (i = 0, section = section_headers;
9620        i < elf_header.e_shnum;
9621        i++, section++)
9622     {
9623       switch (section->sh_type)
9624         {
9625         case SHT_GNU_verdef:
9626           {
9627             Elf_External_Verdef * edefs;
9628             unsigned int idx;
9629             unsigned int cnt;
9630             char * endbuf;
9631
9632             found = 1;
9633
9634             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9635                     printable_section_name (section),
9636                     section->sh_info);
9637
9638             printf (_("  Addr: 0x"));
9639             printf_vma (section->sh_addr);
9640             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9641                     (unsigned long) section->sh_offset, section->sh_link,
9642                     printable_section_name_from_index (section->sh_link));
9643
9644             edefs = (Elf_External_Verdef *)
9645                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9646                           _("version definition section"));
9647             if (!edefs)
9648               break;
9649             endbuf = (char *) edefs + section->sh_size;
9650
9651             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9652               {
9653                 char * vstart;
9654                 Elf_External_Verdef * edef;
9655                 Elf_Internal_Verdef ent;
9656                 Elf_External_Verdaux * eaux;
9657                 Elf_Internal_Verdaux aux;
9658                 int j;
9659                 int isum;
9660
9661                 /* Check for very large indicies.  */
9662                 if (idx > (size_t) (endbuf - (char *) edefs))
9663                   break;
9664
9665                 vstart = ((char *) edefs) + idx;
9666                 if (vstart + sizeof (*edef) > endbuf)
9667                   break;
9668
9669                 edef = (Elf_External_Verdef *) vstart;
9670
9671                 ent.vd_version = BYTE_GET (edef->vd_version);
9672                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9673                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9674                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9675                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9676                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9677                 ent.vd_next    = BYTE_GET (edef->vd_next);
9678
9679                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9680                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9681
9682                 printf (_("  Index: %d  Cnt: %d  "),
9683                         ent.vd_ndx, ent.vd_cnt);
9684
9685                 /* Check for overflow.  */
9686                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9687                   break;
9688
9689                 vstart += ent.vd_aux;
9690
9691                 eaux = (Elf_External_Verdaux *) vstart;
9692
9693                 aux.vda_name = BYTE_GET (eaux->vda_name);
9694                 aux.vda_next = BYTE_GET (eaux->vda_next);
9695
9696                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9697                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9698                 else
9699                   printf (_("Name index: %ld\n"), aux.vda_name);
9700
9701                 isum = idx + ent.vd_aux;
9702
9703                 for (j = 1; j < ent.vd_cnt; j++)
9704                   {
9705                     /* Check for overflow.  */
9706                     if (aux.vda_next > (size_t) (endbuf - vstart))
9707                       break;
9708
9709                     isum   += aux.vda_next;
9710                     vstart += aux.vda_next;
9711
9712                     eaux = (Elf_External_Verdaux *) vstart;
9713                     if (vstart + sizeof (*eaux) > endbuf)
9714                       break;
9715
9716                     aux.vda_name = BYTE_GET (eaux->vda_name);
9717                     aux.vda_next = BYTE_GET (eaux->vda_next);
9718
9719                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9720                       printf (_("  %#06x: Parent %d: %s\n"),
9721                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9722                     else
9723                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9724                               isum, j, aux.vda_name);
9725                   }
9726
9727                 if (j < ent.vd_cnt)
9728                   printf (_("  Version def aux past end of section\n"));
9729
9730                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9731                 if (idx + ent.vd_next <= idx)
9732                   break;
9733
9734                 idx += ent.vd_next;
9735               }
9736
9737             if (cnt < section->sh_info)
9738               printf (_("  Version definition past end of section\n"));
9739
9740             free (edefs);
9741           }
9742           break;
9743
9744         case SHT_GNU_verneed:
9745           {
9746             Elf_External_Verneed * eneed;
9747             unsigned int idx;
9748             unsigned int cnt;
9749             char * endbuf;
9750
9751             found = 1;
9752
9753             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9754                     printable_section_name (section), section->sh_info);
9755
9756             printf (_(" Addr: 0x"));
9757             printf_vma (section->sh_addr);
9758             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9759                     (unsigned long) section->sh_offset, section->sh_link,
9760                     printable_section_name_from_index (section->sh_link));
9761
9762             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9763                                                        section->sh_offset, 1,
9764                                                        section->sh_size,
9765                                                        _("Version Needs section"));
9766             if (!eneed)
9767               break;
9768             endbuf = (char *) eneed + section->sh_size;
9769
9770             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9771               {
9772                 Elf_External_Verneed * entry;
9773                 Elf_Internal_Verneed ent;
9774                 int j;
9775                 int isum;
9776                 char * vstart;
9777
9778                 if (idx > (size_t) (endbuf - (char *) eneed))
9779                   break;
9780
9781                 vstart = ((char *) eneed) + idx;
9782                 if (vstart + sizeof (*entry) > endbuf)
9783                   break;
9784
9785                 entry = (Elf_External_Verneed *) vstart;
9786
9787                 ent.vn_version = BYTE_GET (entry->vn_version);
9788                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9789                 ent.vn_file    = BYTE_GET (entry->vn_file);
9790                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9791                 ent.vn_next    = BYTE_GET (entry->vn_next);
9792
9793                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9794
9795                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9796                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9797                 else
9798                   printf (_("  File: %lx"), ent.vn_file);
9799
9800                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9801
9802                 /* Check for overflow.  */
9803                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9804                   break;
9805                 vstart += ent.vn_aux;
9806
9807                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9808                   {
9809                     Elf_External_Vernaux * eaux;
9810                     Elf_Internal_Vernaux aux;
9811
9812                     if (vstart + sizeof (*eaux) > endbuf)
9813                       break;
9814                     eaux = (Elf_External_Vernaux *) vstart;
9815
9816                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9817                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9818                     aux.vna_other = BYTE_GET (eaux->vna_other);
9819                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9820                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9821
9822                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9823                       printf (_("  %#06x:   Name: %s"),
9824                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9825                     else
9826                       printf (_("  %#06x:   Name index: %lx"),
9827                               isum, aux.vna_name);
9828
9829                     printf (_("  Flags: %s  Version: %d\n"),
9830                             get_ver_flags (aux.vna_flags), aux.vna_other);
9831
9832                     /* Check for overflow.  */
9833                     if (aux.vna_next > (size_t) (endbuf - vstart)
9834                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9835                       {
9836                         warn (_("Invalid vna_next field of %lx\n"),
9837                               aux.vna_next);
9838                         j = ent.vn_cnt;
9839                         break;
9840                       }
9841                     isum   += aux.vna_next;
9842                     vstart += aux.vna_next;
9843                   }
9844
9845                 if (j < ent.vn_cnt)
9846                   warn (_("Missing Version Needs auxillary information\n"));
9847
9848                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9849                   {
9850                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9851                     cnt = section->sh_info;
9852                     break;
9853                   }
9854                 idx += ent.vn_next;
9855               }
9856
9857             if (cnt < section->sh_info)
9858               warn (_("Missing Version Needs information\n"));
9859
9860             free (eneed);
9861           }
9862           break;
9863
9864         case SHT_GNU_versym:
9865           {
9866             Elf_Internal_Shdr * link_section;
9867             size_t total;
9868             unsigned int cnt;
9869             unsigned char * edata;
9870             unsigned short * data;
9871             char * strtab;
9872             Elf_Internal_Sym * symbols;
9873             Elf_Internal_Shdr * string_sec;
9874             unsigned long num_syms;
9875             long off;
9876
9877             if (section->sh_link >= elf_header.e_shnum)
9878               break;
9879
9880             link_section = section_headers + section->sh_link;
9881             total = section->sh_size / sizeof (Elf_External_Versym);
9882
9883             if (link_section->sh_link >= elf_header.e_shnum)
9884               break;
9885
9886             found = 1;
9887
9888             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9889             if (symbols == NULL)
9890               break;
9891
9892             string_sec = section_headers + link_section->sh_link;
9893
9894             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9895                                         string_sec->sh_size,
9896                                         _("version string table"));
9897             if (!strtab)
9898               {
9899                 free (symbols);
9900                 break;
9901               }
9902
9903             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9904                     printable_section_name (section), (unsigned long) total);
9905
9906             printf (_(" Addr: "));
9907             printf_vma (section->sh_addr);
9908             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9909                     (unsigned long) section->sh_offset, section->sh_link,
9910                     printable_section_name (link_section));
9911
9912             off = offset_from_vma (file,
9913                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9914                                    total * sizeof (short));
9915             edata = (unsigned char *) get_data (NULL, file, off, total,
9916                                                 sizeof (short),
9917                                                 _("version symbol data"));
9918             if (!edata)
9919               {
9920                 free (strtab);
9921                 free (symbols);
9922                 break;
9923               }
9924
9925             data = (short unsigned int *) cmalloc (total, sizeof (short));
9926
9927             for (cnt = total; cnt --;)
9928               data[cnt] = byte_get (edata + cnt * sizeof (short),
9929                                     sizeof (short));
9930
9931             free (edata);
9932
9933             for (cnt = 0; cnt < total; cnt += 4)
9934               {
9935                 int j, nn;
9936                 char *name;
9937                 char *invalid = _("*invalid*");
9938
9939                 printf ("  %03x:", cnt);
9940
9941                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9942                   switch (data[cnt + j])
9943                     {
9944                     case 0:
9945                       fputs (_("   0 (*local*)    "), stdout);
9946                       break;
9947
9948                     case 1:
9949                       fputs (_("   1 (*global*)   "), stdout);
9950                       break;
9951
9952                     default:
9953                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9954                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9955
9956                       /* If this index value is greater than the size of the symbols
9957                          array, break to avoid an out-of-bounds read.  */
9958                       if ((unsigned long)(cnt + j) >= num_syms)
9959                         {
9960                           warn (_("invalid index into symbol array\n"));
9961                           break;
9962                         }
9963
9964                       name = NULL;
9965                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9966                         {
9967                           Elf_Internal_Verneed ivn;
9968                           unsigned long offset;
9969
9970                           offset = offset_from_vma
9971                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9972                              sizeof (Elf_External_Verneed));
9973
9974                           do
9975                             {
9976                               Elf_Internal_Vernaux ivna;
9977                               Elf_External_Verneed evn;
9978                               Elf_External_Vernaux evna;
9979                               unsigned long a_off;
9980
9981                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9982                                             _("version need")) == NULL)
9983                                 break;
9984
9985                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9986                               ivn.vn_next = BYTE_GET (evn.vn_next);
9987
9988                               a_off = offset + ivn.vn_aux;
9989
9990                               do
9991                                 {
9992                                   if (get_data (&evna, file, a_off, sizeof (evna),
9993                                                 1, _("version need aux (2)")) == NULL)
9994                                     {
9995                                       ivna.vna_next  = 0;
9996                                       ivna.vna_other = 0;
9997                                     }
9998                                   else
9999                                     {
10000                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10001                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10002                                     }
10003
10004                                   a_off += ivna.vna_next;
10005                                 }
10006                               while (ivna.vna_other != data[cnt + j]
10007                                      && ivna.vna_next != 0);
10008
10009                               if (ivna.vna_other == data[cnt + j])
10010                                 {
10011                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10012
10013                                   if (ivna.vna_name >= string_sec->sh_size)
10014                                     name = invalid;
10015                                   else
10016                                     name = strtab + ivna.vna_name;
10017                                   break;
10018                                 }
10019
10020                               offset += ivn.vn_next;
10021                             }
10022                           while (ivn.vn_next);
10023                         }
10024
10025                       if (data[cnt + j] != 0x8001
10026                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10027                         {
10028                           Elf_Internal_Verdef ivd;
10029                           Elf_External_Verdef evd;
10030                           unsigned long offset;
10031
10032                           offset = offset_from_vma
10033                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10034                              sizeof evd);
10035
10036                           do
10037                             {
10038                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10039                                             _("version def")) == NULL)
10040                                 {
10041                                   ivd.vd_next = 0;
10042                                   /* PR 17531: file: 046-1082287-0.004.  */
10043                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10044                                   break;
10045                                 }
10046                               else
10047                                 {
10048                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10049                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10050                                 }
10051
10052                               offset += ivd.vd_next;
10053                             }
10054                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10055                                  && ivd.vd_next != 0);
10056
10057                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10058                             {
10059                               Elf_External_Verdaux evda;
10060                               Elf_Internal_Verdaux ivda;
10061
10062                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10063
10064                               if (get_data (&evda, file,
10065                                             offset - ivd.vd_next + ivd.vd_aux,
10066                                             sizeof (evda), 1,
10067                                             _("version def aux")) == NULL)
10068                                 break;
10069
10070                               ivda.vda_name = BYTE_GET (evda.vda_name);
10071
10072                               if (ivda.vda_name >= string_sec->sh_size)
10073                                 name = invalid;
10074                               else if (name != NULL && name != invalid)
10075                                 name = _("*both*");
10076                               else
10077                                 name = strtab + ivda.vda_name;
10078                             }
10079                         }
10080                       if (name != NULL)
10081                         nn += printf ("(%s%-*s",
10082                                       name,
10083                                       12 - (int) strlen (name),
10084                                       ")");
10085
10086                       if (nn < 18)
10087                         printf ("%*c", 18 - nn, ' ');
10088                     }
10089
10090                 putchar ('\n');
10091               }
10092
10093             free (data);
10094             free (strtab);
10095             free (symbols);
10096           }
10097           break;
10098
10099         default:
10100           break;
10101         }
10102     }
10103
10104   if (! found)
10105     printf (_("\nNo version information found in this file.\n"));
10106
10107   return 1;
10108 }
10109
10110 static const char *
10111 get_symbol_binding (unsigned int binding)
10112 {
10113   static char buff[32];
10114
10115   switch (binding)
10116     {
10117     case STB_LOCAL:     return "LOCAL";
10118     case STB_GLOBAL:    return "GLOBAL";
10119     case STB_WEAK:      return "WEAK";
10120     default:
10121       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10122         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10123                   binding);
10124       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10125         {
10126           if (binding == STB_GNU_UNIQUE
10127               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10128                   /* GNU is still using the default value 0.  */
10129                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10130             return "UNIQUE";
10131           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10132         }
10133       else
10134         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10135       return buff;
10136     }
10137 }
10138
10139 static const char *
10140 get_symbol_type (unsigned int type)
10141 {
10142   static char buff[32];
10143
10144   switch (type)
10145     {
10146     case STT_NOTYPE:    return "NOTYPE";
10147     case STT_OBJECT:    return "OBJECT";
10148     case STT_FUNC:      return "FUNC";
10149     case STT_SECTION:   return "SECTION";
10150     case STT_FILE:      return "FILE";
10151     case STT_COMMON:    return "COMMON";
10152     case STT_TLS:       return "TLS";
10153     case STT_RELC:      return "RELC";
10154     case STT_SRELC:     return "SRELC";
10155     default:
10156       if (type >= STT_LOPROC && type <= STT_HIPROC)
10157         {
10158           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10159             return "THUMB_FUNC";
10160
10161           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10162             return "REGISTER";
10163
10164           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10165             return "PARISC_MILLI";
10166
10167           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10168         }
10169       else if (type >= STT_LOOS && type <= STT_HIOS)
10170         {
10171           if (elf_header.e_machine == EM_PARISC)
10172             {
10173               if (type == STT_HP_OPAQUE)
10174                 return "HP_OPAQUE";
10175               if (type == STT_HP_STUB)
10176                 return "HP_STUB";
10177             }
10178
10179           if (type == STT_GNU_IFUNC
10180               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10181                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10182                   /* GNU is still using the default value 0.  */
10183                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10184             return "IFUNC";
10185
10186           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10187         }
10188       else
10189         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10190       return buff;
10191     }
10192 }
10193
10194 static const char *
10195 get_symbol_visibility (unsigned int visibility)
10196 {
10197   switch (visibility)
10198     {
10199     case STV_DEFAULT:   return "DEFAULT";
10200     case STV_INTERNAL:  return "INTERNAL";
10201     case STV_HIDDEN:    return "HIDDEN";
10202     case STV_PROTECTED: return "PROTECTED";
10203     default:
10204       error (_("Unrecognized visibility value: %u"), visibility);
10205       return _("<unknown>");
10206     }
10207 }
10208
10209 static const char *
10210 get_mips_symbol_other (unsigned int other)
10211 {
10212   switch (other)
10213     {
10214     case STO_OPTIONAL:
10215       return "OPTIONAL";
10216     case STO_MIPS_PLT:
10217       return "MIPS PLT";
10218     case STO_MIPS_PIC:
10219       return "MIPS PIC";
10220     case STO_MICROMIPS:
10221       return "MICROMIPS";
10222     case STO_MICROMIPS | STO_MIPS_PIC:
10223       return "MICROMIPS, MIPS PIC";
10224     case STO_MIPS16:
10225       return "MIPS16";
10226     default:
10227       return NULL;
10228     }
10229 }
10230
10231 static const char *
10232 get_ia64_symbol_other (unsigned int other)
10233 {
10234   if (is_ia64_vms ())
10235     {
10236       static char res[32];
10237
10238       res[0] = 0;
10239
10240       /* Function types is for images and .STB files only.  */
10241       switch (elf_header.e_type)
10242         {
10243         case ET_DYN:
10244         case ET_EXEC:
10245           switch (VMS_ST_FUNC_TYPE (other))
10246             {
10247             case VMS_SFT_CODE_ADDR:
10248               strcat (res, " CA");
10249               break;
10250             case VMS_SFT_SYMV_IDX:
10251               strcat (res, " VEC");
10252               break;
10253             case VMS_SFT_FD:
10254               strcat (res, " FD");
10255               break;
10256             case VMS_SFT_RESERVE:
10257               strcat (res, " RSV");
10258               break;
10259             default:
10260               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10261                     VMS_ST_FUNC_TYPE (other));
10262               strcat (res, " <unknown>");
10263               break;
10264             }
10265           break;
10266         default:
10267           break;
10268         }
10269       switch (VMS_ST_LINKAGE (other))
10270         {
10271         case VMS_STL_IGNORE:
10272           strcat (res, " IGN");
10273           break;
10274         case VMS_STL_RESERVE:
10275           strcat (res, " RSV");
10276           break;
10277         case VMS_STL_STD:
10278           strcat (res, " STD");
10279           break;
10280         case VMS_STL_LNK:
10281           strcat (res, " LNK");
10282           break;
10283         default:
10284           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10285                 VMS_ST_LINKAGE (other));
10286           strcat (res, " <unknown>");
10287           break;
10288         }
10289
10290       if (res[0] != 0)
10291         return res + 1;
10292       else
10293         return res;
10294     }
10295   return NULL;
10296 }
10297
10298 static const char *
10299 get_ppc64_symbol_other (unsigned int other)
10300 {
10301   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10302     {
10303       static char buf[32];
10304       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10305                 PPC64_LOCAL_ENTRY_OFFSET (other));
10306       return buf;
10307     }
10308   return NULL;
10309 }
10310
10311 static const char *
10312 get_symbol_other (unsigned int other)
10313 {
10314   const char * result = NULL;
10315   static char buff [32];
10316
10317   if (other == 0)
10318     return "";
10319
10320   switch (elf_header.e_machine)
10321     {
10322     case EM_MIPS:
10323       result = get_mips_symbol_other (other);
10324       break;
10325     case EM_IA_64:
10326       result = get_ia64_symbol_other (other);
10327       break;
10328     case EM_PPC64:
10329       result = get_ppc64_symbol_other (other);
10330       break;
10331     default:
10332       break;
10333     }
10334
10335   if (result)
10336     return result;
10337
10338   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10339   return buff;
10340 }
10341
10342 static const char *
10343 get_symbol_index_type (unsigned int type)
10344 {
10345   static char buff[32];
10346
10347   switch (type)
10348     {
10349     case SHN_UNDEF:     return "UND";
10350     case SHN_ABS:       return "ABS";
10351     case SHN_COMMON:    return "COM";
10352     default:
10353       if (type == SHN_IA_64_ANSI_COMMON
10354           && elf_header.e_machine == EM_IA_64
10355           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10356         return "ANSI_COM";
10357       else if ((elf_header.e_machine == EM_X86_64
10358                 || elf_header.e_machine == EM_L1OM
10359                 || elf_header.e_machine == EM_K1OM)
10360                && type == SHN_X86_64_LCOMMON)
10361         return "LARGE_COM";
10362       else if ((type == SHN_MIPS_SCOMMON
10363                 && elf_header.e_machine == EM_MIPS)
10364                || (type == SHN_TIC6X_SCOMMON
10365                    && elf_header.e_machine == EM_TI_C6000))
10366         return "SCOM";
10367       else if (type == SHN_MIPS_SUNDEFINED
10368                && elf_header.e_machine == EM_MIPS)
10369         return "SUND";
10370       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10371         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10372       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10373         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10374       else if (type >= SHN_LORESERVE)
10375         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10376       else if (type >= elf_header.e_shnum)
10377         sprintf (buff, _("bad section index[%3d]"), type);
10378       else
10379         sprintf (buff, "%3d", type);
10380       break;
10381     }
10382
10383   return buff;
10384 }
10385
10386 static bfd_vma *
10387 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10388 {
10389   unsigned char * e_data;
10390   bfd_vma * i_data;
10391
10392   /* If the size_t type is smaller than the bfd_size_type, eg because
10393      you are building a 32-bit tool on a 64-bit host, then make sure
10394      that when (number) is cast to (size_t) no information is lost.  */
10395   if (sizeof (size_t) < sizeof (bfd_size_type)
10396       && (bfd_size_type) ((size_t) number) != number)
10397     {
10398       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10399              (unsigned long long) number, ent_size);
10400       return NULL;
10401     }
10402
10403   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10404      attempting to allocate memory when the read is bound to fail.  */
10405   if (ent_size * number > current_file_size)
10406     {
10407       error (_("Invalid number of dynamic entries: %llu\n"),
10408              (unsigned long long) number);
10409       return NULL;
10410     }
10411
10412   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10413   if (e_data == NULL)
10414     {
10415       error (_("Out of memory reading %llu dynamic entries\n"),
10416              (unsigned long long) number);
10417       return NULL;
10418     }
10419
10420   if (fread (e_data, ent_size, (size_t) number, file) != number)
10421     {
10422       error (_("Unable to read in %llu bytes of dynamic data\n"),
10423              (unsigned long long) (number * ent_size));
10424       free (e_data);
10425       return NULL;
10426     }
10427
10428   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10429   if (i_data == NULL)
10430     {
10431       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10432              (unsigned long long) number);
10433       free (e_data);
10434       return NULL;
10435     }
10436
10437   while (number--)
10438     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10439
10440   free (e_data);
10441
10442   return i_data;
10443 }
10444
10445 static void
10446 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10447 {
10448   Elf_Internal_Sym * psym;
10449   int n;
10450
10451   n = print_vma (si, DEC_5);
10452   if (n < 5)
10453     fputs (&"     "[n], stdout);
10454   printf (" %3lu: ", hn);
10455
10456   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10457     {
10458       printf (_("<No info available for dynamic symbol number %lu>\n"),
10459               (unsigned long) si);
10460       return;
10461     }
10462
10463   psym = dynamic_symbols + si;
10464   print_vma (psym->st_value, LONG_HEX);
10465   putchar (' ');
10466   print_vma (psym->st_size, DEC_5);
10467
10468   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10469   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10470   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10471   /* Check to see if any other bits in the st_other field are set.
10472      Note - displaying this information disrupts the layout of the
10473      table being generated, but for the moment this case is very
10474      rare.  */
10475   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10476     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10477   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10478   if (VALID_DYNAMIC_NAME (psym->st_name))
10479     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10480   else
10481     printf (_(" <corrupt: %14ld>"), psym->st_name);
10482   putchar ('\n');
10483 }
10484
10485 static const char *
10486 get_symbol_version_string (FILE *file, int is_dynsym,
10487                            const char *strtab,
10488                            unsigned long int strtab_size,
10489                            unsigned int si, Elf_Internal_Sym *psym,
10490                            enum versioned_symbol_info *sym_info,
10491                            unsigned short *vna_other)
10492 {
10493   unsigned char data[2];
10494   unsigned short vers_data;
10495   unsigned long offset;
10496
10497   if (!is_dynsym
10498       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10499     return NULL;
10500
10501   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10502                             sizeof data + si * sizeof (vers_data));
10503
10504   if (get_data (&data, file, offset + si * sizeof (vers_data),
10505                 sizeof (data), 1, _("version data")) == NULL)
10506     return NULL;
10507
10508   vers_data = byte_get (data, 2);
10509
10510   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10511     return NULL;
10512
10513   /* Usually we'd only see verdef for defined symbols, and verneed for
10514      undefined symbols.  However, symbols defined by the linker in
10515      .dynbss for variables copied from a shared library in order to
10516      avoid text relocations are defined yet have verneed.  We could
10517      use a heuristic to detect the special case, for example, check
10518      for verneed first on symbols defined in SHT_NOBITS sections, but
10519      it is simpler and more reliable to just look for both verdef and
10520      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
10521
10522   if (psym->st_shndx != SHN_UNDEF
10523       && vers_data != 0x8001
10524       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10525     {
10526       Elf_Internal_Verdef ivd;
10527       Elf_Internal_Verdaux ivda;
10528       Elf_External_Verdaux evda;
10529       unsigned long off;
10530
10531       off = offset_from_vma (file,
10532                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10533                              sizeof (Elf_External_Verdef));
10534
10535       do
10536         {
10537           Elf_External_Verdef evd;
10538
10539           if (get_data (&evd, file, off, sizeof (evd), 1,
10540                         _("version def")) == NULL)
10541             {
10542               ivd.vd_ndx = 0;
10543               ivd.vd_aux = 0;
10544               ivd.vd_next = 0;
10545             }
10546           else
10547             {
10548               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10549               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10550               ivd.vd_next = BYTE_GET (evd.vd_next);
10551             }
10552
10553           off += ivd.vd_next;
10554         }
10555       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10556
10557       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10558         {
10559           off -= ivd.vd_next;
10560           off += ivd.vd_aux;
10561
10562           if (get_data (&evda, file, off, sizeof (evda), 1,
10563                         _("version def aux")) != NULL)
10564             {
10565               ivda.vda_name = BYTE_GET (evda.vda_name);
10566
10567               if (psym->st_name != ivda.vda_name)
10568                 {
10569                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10570                                ? symbol_hidden : symbol_public);
10571                   return (ivda.vda_name < strtab_size
10572                           ? strtab + ivda.vda_name : _("<corrupt>"));
10573                 }
10574             }
10575         }
10576     }
10577
10578   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10579     {
10580       Elf_External_Verneed evn;
10581       Elf_Internal_Verneed ivn;
10582       Elf_Internal_Vernaux ivna;
10583
10584       offset = offset_from_vma (file,
10585                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10586                                 sizeof evn);
10587       do
10588         {
10589           unsigned long vna_off;
10590
10591           if (get_data (&evn, file, offset, sizeof (evn), 1,
10592                         _("version need")) == NULL)
10593             {
10594               ivna.vna_next = 0;
10595               ivna.vna_other = 0;
10596               ivna.vna_name = 0;
10597               break;
10598             }
10599
10600           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10601           ivn.vn_next = BYTE_GET (evn.vn_next);
10602
10603           vna_off = offset + ivn.vn_aux;
10604
10605           do
10606             {
10607               Elf_External_Vernaux evna;
10608
10609               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10610                             _("version need aux (3)")) == NULL)
10611                 {
10612                   ivna.vna_next = 0;
10613                   ivna.vna_other = 0;
10614                   ivna.vna_name = 0;
10615                 }
10616               else
10617                 {
10618                   ivna.vna_other = BYTE_GET (evna.vna_other);
10619                   ivna.vna_next  = BYTE_GET (evna.vna_next);
10620                   ivna.vna_name  = BYTE_GET (evna.vna_name);
10621                 }
10622
10623               vna_off += ivna.vna_next;
10624             }
10625           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
10626
10627           if (ivna.vna_other == vers_data)
10628             break;
10629
10630           offset += ivn.vn_next;
10631         }
10632       while (ivn.vn_next != 0);
10633
10634       if (ivna.vna_other == vers_data)
10635         {
10636           *sym_info = symbol_undefined;
10637           *vna_other = ivna.vna_other;
10638           return (ivna.vna_name < strtab_size
10639                   ? strtab + ivna.vna_name : _("<corrupt>"));
10640         }
10641     }
10642   return NULL;
10643 }
10644
10645 /* Dump the symbol table.  */
10646 static int
10647 process_symbol_table (FILE * file)
10648 {
10649   Elf_Internal_Shdr * section;
10650   bfd_size_type nbuckets = 0;
10651   bfd_size_type nchains = 0;
10652   bfd_vma * buckets = NULL;
10653   bfd_vma * chains = NULL;
10654   bfd_vma ngnubuckets = 0;
10655   bfd_vma * gnubuckets = NULL;
10656   bfd_vma * gnuchains = NULL;
10657   bfd_vma gnusymidx = 0;
10658   bfd_size_type ngnuchains = 0;
10659
10660   if (!do_syms && !do_dyn_syms && !do_histogram)
10661     return 1;
10662
10663   if (dynamic_info[DT_HASH]
10664       && (do_histogram
10665           || (do_using_dynamic
10666               && !do_dyn_syms
10667               && dynamic_strings != NULL)))
10668     {
10669       unsigned char nb[8];
10670       unsigned char nc[8];
10671       unsigned int hash_ent_size = 4;
10672
10673       if ((elf_header.e_machine == EM_ALPHA
10674            || elf_header.e_machine == EM_S390
10675            || elf_header.e_machine == EM_S390_OLD)
10676           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10677         hash_ent_size = 8;
10678
10679       if (fseek (file,
10680                  (archive_file_offset
10681                   + offset_from_vma (file, dynamic_info[DT_HASH],
10682                                      sizeof nb + sizeof nc)),
10683                  SEEK_SET))
10684         {
10685           error (_("Unable to seek to start of dynamic information\n"));
10686           goto no_hash;
10687         }
10688
10689       if (fread (nb, hash_ent_size, 1, file) != 1)
10690         {
10691           error (_("Failed to read in number of buckets\n"));
10692           goto no_hash;
10693         }
10694
10695       if (fread (nc, hash_ent_size, 1, file) != 1)
10696         {
10697           error (_("Failed to read in number of chains\n"));
10698           goto no_hash;
10699         }
10700
10701       nbuckets = byte_get (nb, hash_ent_size);
10702       nchains  = byte_get (nc, hash_ent_size);
10703
10704       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10705       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10706
10707     no_hash:
10708       if (buckets == NULL || chains == NULL)
10709         {
10710           if (do_using_dynamic)
10711             return 0;
10712           free (buckets);
10713           free (chains);
10714           buckets = NULL;
10715           chains = NULL;
10716           nbuckets = 0;
10717           nchains = 0;
10718         }
10719     }
10720
10721   if (dynamic_info_DT_GNU_HASH
10722       && (do_histogram
10723           || (do_using_dynamic
10724               && !do_dyn_syms
10725               && dynamic_strings != NULL)))
10726     {
10727       unsigned char nb[16];
10728       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10729       bfd_vma buckets_vma;
10730
10731       if (fseek (file,
10732                  (archive_file_offset
10733                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10734                                      sizeof nb)),
10735                  SEEK_SET))
10736         {
10737           error (_("Unable to seek to start of dynamic information\n"));
10738           goto no_gnu_hash;
10739         }
10740
10741       if (fread (nb, 16, 1, file) != 1)
10742         {
10743           error (_("Failed to read in number of buckets\n"));
10744           goto no_gnu_hash;
10745         }
10746
10747       ngnubuckets = byte_get (nb, 4);
10748       gnusymidx = byte_get (nb + 4, 4);
10749       bitmaskwords = byte_get (nb + 8, 4);
10750       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10751       if (is_32bit_elf)
10752         buckets_vma += bitmaskwords * 4;
10753       else
10754         buckets_vma += bitmaskwords * 8;
10755
10756       if (fseek (file,
10757                  (archive_file_offset
10758                   + offset_from_vma (file, buckets_vma, 4)),
10759                  SEEK_SET))
10760         {
10761           error (_("Unable to seek to start of dynamic information\n"));
10762           goto no_gnu_hash;
10763         }
10764
10765       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10766
10767       if (gnubuckets == NULL)
10768         goto no_gnu_hash;
10769
10770       for (i = 0; i < ngnubuckets; i++)
10771         if (gnubuckets[i] != 0)
10772           {
10773             if (gnubuckets[i] < gnusymidx)
10774               return 0;
10775
10776             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10777               maxchain = gnubuckets[i];
10778           }
10779
10780       if (maxchain == 0xffffffff)
10781         goto no_gnu_hash;
10782
10783       maxchain -= gnusymidx;
10784
10785       if (fseek (file,
10786                  (archive_file_offset
10787                   + offset_from_vma (file, buckets_vma
10788                                            + 4 * (ngnubuckets + maxchain), 4)),
10789                  SEEK_SET))
10790         {
10791           error (_("Unable to seek to start of dynamic information\n"));
10792           goto no_gnu_hash;
10793         }
10794
10795       do
10796         {
10797           if (fread (nb, 4, 1, file) != 1)
10798             {
10799               error (_("Failed to determine last chain length\n"));
10800               goto no_gnu_hash;
10801             }
10802
10803           if (maxchain + 1 == 0)
10804             goto no_gnu_hash;
10805
10806           ++maxchain;
10807         }
10808       while ((byte_get (nb, 4) & 1) == 0);
10809
10810       if (fseek (file,
10811                  (archive_file_offset
10812                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10813                  SEEK_SET))
10814         {
10815           error (_("Unable to seek to start of dynamic information\n"));
10816           goto no_gnu_hash;
10817         }
10818
10819       gnuchains = get_dynamic_data (file, maxchain, 4);
10820       ngnuchains = maxchain;
10821
10822     no_gnu_hash:
10823       if (gnuchains == NULL)
10824         {
10825           free (gnubuckets);
10826           gnubuckets = NULL;
10827           ngnubuckets = 0;
10828           if (do_using_dynamic)
10829             return 0;
10830         }
10831     }
10832
10833   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10834       && do_syms
10835       && do_using_dynamic
10836       && dynamic_strings != NULL
10837       && dynamic_symbols != NULL)
10838     {
10839       unsigned long hn;
10840
10841       if (dynamic_info[DT_HASH])
10842         {
10843           bfd_vma si;
10844
10845           printf (_("\nSymbol table for image:\n"));
10846           if (is_32bit_elf)
10847             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10848           else
10849             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10850
10851           for (hn = 0; hn < nbuckets; hn++)
10852             {
10853               if (! buckets[hn])
10854                 continue;
10855
10856               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10857                 print_dynamic_symbol (si, hn);
10858             }
10859         }
10860
10861       if (dynamic_info_DT_GNU_HASH)
10862         {
10863           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10864           if (is_32bit_elf)
10865             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10866           else
10867             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10868
10869           for (hn = 0; hn < ngnubuckets; ++hn)
10870             if (gnubuckets[hn] != 0)
10871               {
10872                 bfd_vma si = gnubuckets[hn];
10873                 bfd_vma off = si - gnusymidx;
10874
10875                 do
10876                   {
10877                     print_dynamic_symbol (si, hn);
10878                     si++;
10879                   }
10880                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10881               }
10882         }
10883     }
10884   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10885            && section_headers != NULL)
10886     {
10887       unsigned int i;
10888
10889       for (i = 0, section = section_headers;
10890            i < elf_header.e_shnum;
10891            i++, section++)
10892         {
10893           unsigned int si;
10894           char * strtab = NULL;
10895           unsigned long int strtab_size = 0;
10896           Elf_Internal_Sym * symtab;
10897           Elf_Internal_Sym * psym;
10898           unsigned long num_syms;
10899
10900           if ((section->sh_type != SHT_SYMTAB
10901                && section->sh_type != SHT_DYNSYM)
10902               || (!do_syms
10903                   && section->sh_type == SHT_SYMTAB))
10904             continue;
10905
10906           if (section->sh_entsize == 0)
10907             {
10908               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10909                       printable_section_name (section));
10910               continue;
10911             }
10912
10913           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10914                   printable_section_name (section),
10915                   (unsigned long) (section->sh_size / section->sh_entsize));
10916
10917           if (is_32bit_elf)
10918             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10919           else
10920             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10921
10922           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10923           if (symtab == NULL)
10924             continue;
10925
10926           if (section->sh_link == elf_header.e_shstrndx)
10927             {
10928               strtab = string_table;
10929               strtab_size = string_table_length;
10930             }
10931           else if (section->sh_link < elf_header.e_shnum)
10932             {
10933               Elf_Internal_Shdr * string_sec;
10934
10935               string_sec = section_headers + section->sh_link;
10936
10937               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10938                                           1, string_sec->sh_size,
10939                                           _("string table"));
10940               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10941             }
10942
10943           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10944             {
10945               const char *version_string;
10946               enum versioned_symbol_info sym_info;
10947               unsigned short vna_other;
10948
10949               printf ("%6d: ", si);
10950               print_vma (psym->st_value, LONG_HEX);
10951               putchar (' ');
10952               print_vma (psym->st_size, DEC_5);
10953               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10954               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10955               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10956               /* Check to see if any other bits in the st_other field are set.
10957                  Note - displaying this information disrupts the layout of the
10958                  table being generated, but for the moment this case is very rare.  */
10959               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10960                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10961               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10962               print_symbol (25, psym->st_name < strtab_size
10963                             ? strtab + psym->st_name : _("<corrupt>"));
10964
10965               version_string
10966                 = get_symbol_version_string (file,
10967                                              section->sh_type == SHT_DYNSYM,
10968                                              strtab, strtab_size, si,
10969                                              psym, &sym_info, &vna_other);
10970               if (version_string)
10971                 {
10972                   if (sym_info == symbol_undefined)
10973                     printf ("@%s (%d)", version_string, vna_other);
10974                   else
10975                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10976                             version_string);
10977                 }
10978
10979               putchar ('\n');
10980             }
10981
10982           free (symtab);
10983           if (strtab != string_table)
10984             free (strtab);
10985         }
10986     }
10987   else if (do_syms)
10988     printf
10989       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10990
10991   if (do_histogram && buckets != NULL)
10992     {
10993       unsigned long * lengths;
10994       unsigned long * counts;
10995       unsigned long hn;
10996       bfd_vma si;
10997       unsigned long maxlength = 0;
10998       unsigned long nzero_counts = 0;
10999       unsigned long nsyms = 0;
11000       unsigned long chained;
11001
11002       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11003               (unsigned long) nbuckets);
11004
11005       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11006       if (lengths == NULL)
11007         {
11008           error (_("Out of memory allocating space for histogram buckets\n"));
11009           return 0;
11010         }
11011
11012       printf (_(" Length  Number     %% of total  Coverage\n"));
11013       for (hn = 0; hn < nbuckets; ++hn)
11014         {
11015           for (si = buckets[hn], chained = 0;
11016                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11017                si = chains[si], ++chained)
11018             {
11019               ++nsyms;
11020               if (maxlength < ++lengths[hn])
11021                 ++maxlength;
11022             }
11023
11024             /* PR binutils/17531: A corrupt binary could contain broken
11025                histogram data.  Do not go into an infinite loop trying
11026                to process it.  */
11027             if (chained > nchains)
11028               {
11029                 error (_("histogram chain is corrupt\n"));
11030                 break;
11031               }
11032         }
11033
11034       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11035       if (counts == NULL)
11036         {
11037           free (lengths);
11038           error (_("Out of memory allocating space for histogram counts\n"));
11039           return 0;
11040         }
11041
11042       for (hn = 0; hn < nbuckets; ++hn)
11043         ++counts[lengths[hn]];
11044
11045       if (nbuckets > 0)
11046         {
11047           unsigned long i;
11048           printf ("      0  %-10lu (%5.1f%%)\n",
11049                   counts[0], (counts[0] * 100.0) / nbuckets);
11050           for (i = 1; i <= maxlength; ++i)
11051             {
11052               nzero_counts += counts[i] * i;
11053               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11054                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11055                       (nzero_counts * 100.0) / nsyms);
11056             }
11057         }
11058
11059       free (counts);
11060       free (lengths);
11061     }
11062
11063   if (buckets != NULL)
11064     {
11065       free (buckets);
11066       free (chains);
11067     }
11068
11069   if (do_histogram && gnubuckets != NULL)
11070     {
11071       unsigned long * lengths;
11072       unsigned long * counts;
11073       unsigned long hn;
11074       unsigned long maxlength = 0;
11075       unsigned long nzero_counts = 0;
11076       unsigned long nsyms = 0;
11077
11078       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11079               (unsigned long) ngnubuckets);
11080
11081       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11082       if (lengths == NULL)
11083         {
11084           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11085           return 0;
11086         }
11087
11088       printf (_(" Length  Number     %% of total  Coverage\n"));
11089
11090       for (hn = 0; hn < ngnubuckets; ++hn)
11091         if (gnubuckets[hn] != 0)
11092           {
11093             bfd_vma off, length = 1;
11094
11095             for (off = gnubuckets[hn] - gnusymidx;
11096                  /* PR 17531 file: 010-77222-0.004.  */
11097                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11098                  ++off)
11099               ++length;
11100             lengths[hn] = length;
11101             if (length > maxlength)
11102               maxlength = length;
11103             nsyms += length;
11104           }
11105
11106       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11107       if (counts == NULL)
11108         {
11109           free (lengths);
11110           error (_("Out of memory allocating space for gnu histogram counts\n"));
11111           return 0;
11112         }
11113
11114       for (hn = 0; hn < ngnubuckets; ++hn)
11115         ++counts[lengths[hn]];
11116
11117       if (ngnubuckets > 0)
11118         {
11119           unsigned long j;
11120           printf ("      0  %-10lu (%5.1f%%)\n",
11121                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11122           for (j = 1; j <= maxlength; ++j)
11123             {
11124               nzero_counts += counts[j] * j;
11125               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11126                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11127                       (nzero_counts * 100.0) / nsyms);
11128             }
11129         }
11130
11131       free (counts);
11132       free (lengths);
11133       free (gnubuckets);
11134       free (gnuchains);
11135     }
11136
11137   return 1;
11138 }
11139
11140 static int
11141 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11142 {
11143   unsigned int i;
11144
11145   if (dynamic_syminfo == NULL
11146       || !do_dynamic)
11147     /* No syminfo, this is ok.  */
11148     return 1;
11149
11150   /* There better should be a dynamic symbol section.  */
11151   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11152     return 0;
11153
11154   if (dynamic_addr)
11155     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11156             dynamic_syminfo_offset, dynamic_syminfo_nent);
11157
11158   printf (_(" Num: Name                           BoundTo     Flags\n"));
11159   for (i = 0; i < dynamic_syminfo_nent; ++i)
11160     {
11161       unsigned short int flags = dynamic_syminfo[i].si_flags;
11162
11163       printf ("%4d: ", i);
11164       if (i >= num_dynamic_syms)
11165         printf (_("<corrupt index>"));
11166       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11167         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11168       else
11169         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11170       putchar (' ');
11171
11172       switch (dynamic_syminfo[i].si_boundto)
11173         {
11174         case SYMINFO_BT_SELF:
11175           fputs ("SELF       ", stdout);
11176           break;
11177         case SYMINFO_BT_PARENT:
11178           fputs ("PARENT     ", stdout);
11179           break;
11180         default:
11181           if (dynamic_syminfo[i].si_boundto > 0
11182               && dynamic_syminfo[i].si_boundto < dynamic_nent
11183               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11184             {
11185               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11186               putchar (' ' );
11187             }
11188           else
11189             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11190           break;
11191         }
11192
11193       if (flags & SYMINFO_FLG_DIRECT)
11194         printf (" DIRECT");
11195       if (flags & SYMINFO_FLG_PASSTHRU)
11196         printf (" PASSTHRU");
11197       if (flags & SYMINFO_FLG_COPY)
11198         printf (" COPY");
11199       if (flags & SYMINFO_FLG_LAZYLOAD)
11200         printf (" LAZYLOAD");
11201
11202       puts ("");
11203     }
11204
11205   return 1;
11206 }
11207
11208 /* Check to see if the given reloc needs to be handled in a target specific
11209    manner.  If so then process the reloc and return TRUE otherwise return
11210    FALSE.  */
11211
11212 static bfd_boolean
11213 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11214                                 unsigned char *     start,
11215                                 Elf_Internal_Sym *  symtab)
11216 {
11217   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11218
11219   switch (elf_header.e_machine)
11220     {
11221     case EM_MSP430:
11222     case EM_MSP430_OLD:
11223       {
11224         static Elf_Internal_Sym * saved_sym = NULL;
11225
11226         switch (reloc_type)
11227           {
11228           case 10: /* R_MSP430_SYM_DIFF */
11229             if (uses_msp430x_relocs ())
11230               break;
11231           case 21: /* R_MSP430X_SYM_DIFF */
11232             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11233             return TRUE;
11234
11235           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11236           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11237             goto handle_sym_diff;
11238
11239           case 5: /* R_MSP430_16_BYTE */
11240           case 9: /* R_MSP430_8 */
11241             if (uses_msp430x_relocs ())
11242               break;
11243             goto handle_sym_diff;
11244
11245           case 2: /* R_MSP430_ABS16 */
11246           case 15: /* R_MSP430X_ABS16 */
11247             if (! uses_msp430x_relocs ())
11248               break;
11249             goto handle_sym_diff;
11250
11251           handle_sym_diff:
11252             if (saved_sym != NULL)
11253               {
11254                 bfd_vma value;
11255
11256                 value = reloc->r_addend
11257                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11258                      - saved_sym->st_value);
11259
11260                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11261
11262                 saved_sym = NULL;
11263                 return TRUE;
11264               }
11265             break;
11266
11267           default:
11268             if (saved_sym != NULL)
11269               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11270             break;
11271           }
11272         break;
11273       }
11274
11275     case EM_MN10300:
11276     case EM_CYGNUS_MN10300:
11277       {
11278         static Elf_Internal_Sym * saved_sym = NULL;
11279
11280         switch (reloc_type)
11281           {
11282           case 34: /* R_MN10300_ALIGN */
11283             return TRUE;
11284           case 33: /* R_MN10300_SYM_DIFF */
11285             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11286             return TRUE;
11287           case 1: /* R_MN10300_32 */
11288           case 2: /* R_MN10300_16 */
11289             if (saved_sym != NULL)
11290               {
11291                 bfd_vma value;
11292
11293                 value = reloc->r_addend
11294                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11295                      - saved_sym->st_value);
11296
11297                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11298
11299                 saved_sym = NULL;
11300                 return TRUE;
11301               }
11302             break;
11303           default:
11304             if (saved_sym != NULL)
11305               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11306             break;
11307           }
11308         break;
11309       }
11310
11311     case EM_RL78:
11312       {
11313         static bfd_vma saved_sym1 = 0;
11314         static bfd_vma saved_sym2 = 0;
11315         static bfd_vma value;
11316
11317         switch (reloc_type)
11318           {
11319           case 0x80: /* R_RL78_SYM.  */
11320             saved_sym1 = saved_sym2;
11321             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11322             saved_sym2 += reloc->r_addend;
11323             return TRUE;
11324
11325           case 0x83: /* R_RL78_OPsub.  */
11326             value = saved_sym1 - saved_sym2;
11327             saved_sym2 = saved_sym1 = 0;
11328             return TRUE;
11329             break;
11330
11331           case 0x41: /* R_RL78_ABS32.  */
11332             byte_put (start + reloc->r_offset, value, 4);
11333             value = 0;
11334             return TRUE;
11335
11336           case 0x43: /* R_RL78_ABS16.  */
11337             byte_put (start + reloc->r_offset, value, 2);
11338             value = 0;
11339             return TRUE;
11340
11341           default:
11342             break;
11343           }
11344         break;
11345       }
11346     }
11347
11348   return FALSE;
11349 }
11350
11351 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11352    DWARF debug sections.  This is a target specific test.  Note - we do not
11353    go through the whole including-target-headers-multiple-times route, (as
11354    we have already done with <elf/h8.h>) because this would become very
11355    messy and even then this function would have to contain target specific
11356    information (the names of the relocs instead of their numeric values).
11357    FIXME: This is not the correct way to solve this problem.  The proper way
11358    is to have target specific reloc sizing and typing functions created by
11359    the reloc-macros.h header, in the same way that it already creates the
11360    reloc naming functions.  */
11361
11362 static bfd_boolean
11363 is_32bit_abs_reloc (unsigned int reloc_type)
11364 {
11365   switch (elf_header.e_machine)
11366     {
11367     case EM_386:
11368     case EM_IAMCU:
11369       return reloc_type == 1; /* R_386_32.  */
11370     case EM_68K:
11371       return reloc_type == 1; /* R_68K_32.  */
11372     case EM_860:
11373       return reloc_type == 1; /* R_860_32.  */
11374     case EM_960:
11375       return reloc_type == 2; /* R_960_32.  */
11376     case EM_AARCH64:
11377       return reloc_type == 258; /* R_AARCH64_ABS32 */
11378     case EM_ALPHA:
11379       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11380     case EM_ARC:
11381       return reloc_type == 1; /* R_ARC_32.  */
11382     case EM_ARC_COMPACT:
11383     case EM_ARC_COMPACT2:
11384       return reloc_type == 4; /* R_ARC_32.  */
11385     case EM_ARM:
11386       return reloc_type == 2; /* R_ARM_ABS32 */
11387     case EM_AVR_OLD:
11388     case EM_AVR:
11389       return reloc_type == 1;
11390     case EM_ADAPTEVA_EPIPHANY:
11391       return reloc_type == 3;
11392     case EM_BLACKFIN:
11393       return reloc_type == 0x12; /* R_byte4_data.  */
11394     case EM_CRIS:
11395       return reloc_type == 3; /* R_CRIS_32.  */
11396     case EM_CR16:
11397       return reloc_type == 3; /* R_CR16_NUM32.  */
11398     case EM_CRX:
11399       return reloc_type == 15; /* R_CRX_NUM32.  */
11400     case EM_CYGNUS_FRV:
11401       return reloc_type == 1;
11402     case EM_CYGNUS_D10V:
11403     case EM_D10V:
11404       return reloc_type == 6; /* R_D10V_32.  */
11405     case EM_CYGNUS_D30V:
11406     case EM_D30V:
11407       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11408     case EM_DLX:
11409       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11410     case EM_CYGNUS_FR30:
11411     case EM_FR30:
11412       return reloc_type == 3; /* R_FR30_32.  */
11413     case EM_FT32:
11414       return reloc_type == 1; /* R_FT32_32.  */
11415     case EM_H8S:
11416     case EM_H8_300:
11417     case EM_H8_300H:
11418       return reloc_type == 1; /* R_H8_DIR32.  */
11419     case EM_IA_64:
11420       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11421         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11422     case EM_IP2K_OLD:
11423     case EM_IP2K:
11424       return reloc_type == 2; /* R_IP2K_32.  */
11425     case EM_IQ2000:
11426       return reloc_type == 2; /* R_IQ2000_32.  */
11427     case EM_LATTICEMICO32:
11428       return reloc_type == 3; /* R_LM32_32.  */
11429     case EM_M32C_OLD:
11430     case EM_M32C:
11431       return reloc_type == 3; /* R_M32C_32.  */
11432     case EM_M32R:
11433       return reloc_type == 34; /* R_M32R_32_RELA.  */
11434     case EM_68HC11:
11435     case EM_68HC12:
11436       return reloc_type == 6; /* R_M68HC11_32.  */
11437     case EM_MCORE:
11438       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11439     case EM_CYGNUS_MEP:
11440       return reloc_type == 4; /* R_MEP_32.  */
11441     case EM_METAG:
11442       return reloc_type == 2; /* R_METAG_ADDR32.  */
11443     case EM_MICROBLAZE:
11444       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11445     case EM_MIPS:
11446       return reloc_type == 2; /* R_MIPS_32.  */
11447     case EM_MMIX:
11448       return reloc_type == 4; /* R_MMIX_32.  */
11449     case EM_CYGNUS_MN10200:
11450     case EM_MN10200:
11451       return reloc_type == 1; /* R_MN10200_32.  */
11452     case EM_CYGNUS_MN10300:
11453     case EM_MN10300:
11454       return reloc_type == 1; /* R_MN10300_32.  */
11455     case EM_MOXIE:
11456       return reloc_type == 1; /* R_MOXIE_32.  */
11457     case EM_MSP430_OLD:
11458     case EM_MSP430:
11459       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11460     case EM_MT:
11461       return reloc_type == 2; /* R_MT_32.  */
11462     case EM_NDS32:
11463       return reloc_type == 20; /* R_NDS32_RELA.  */
11464     case EM_ALTERA_NIOS2:
11465       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11466     case EM_NIOS32:
11467       return reloc_type == 1; /* R_NIOS_32.  */
11468     case EM_OR1K:
11469       return reloc_type == 1; /* R_OR1K_32.  */
11470     case EM_PARISC:
11471       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11472               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11473     case EM_PJ:
11474     case EM_PJ_OLD:
11475       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11476     case EM_PPC64:
11477       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11478     case EM_PPC:
11479       return reloc_type == 1; /* R_PPC_ADDR32.  */
11480     case EM_RL78:
11481       return reloc_type == 1; /* R_RL78_DIR32.  */
11482     case EM_RX:
11483       return reloc_type == 1; /* R_RX_DIR32.  */
11484     case EM_S370:
11485       return reloc_type == 1; /* R_I370_ADDR31.  */
11486     case EM_S390_OLD:
11487     case EM_S390:
11488       return reloc_type == 4; /* R_S390_32.  */
11489     case EM_SCORE:
11490       return reloc_type == 8; /* R_SCORE_ABS32.  */
11491     case EM_SH:
11492       return reloc_type == 1; /* R_SH_DIR32.  */
11493     case EM_SPARC32PLUS:
11494     case EM_SPARCV9:
11495     case EM_SPARC:
11496       return reloc_type == 3 /* R_SPARC_32.  */
11497         || reloc_type == 23; /* R_SPARC_UA32.  */
11498     case EM_SPU:
11499       return reloc_type == 6; /* R_SPU_ADDR32 */
11500     case EM_TI_C6000:
11501       return reloc_type == 1; /* R_C6000_ABS32.  */
11502     case EM_TILEGX:
11503       return reloc_type == 2; /* R_TILEGX_32.  */
11504     case EM_TILEPRO:
11505       return reloc_type == 1; /* R_TILEPRO_32.  */
11506     case EM_CYGNUS_V850:
11507     case EM_V850:
11508       return reloc_type == 6; /* R_V850_ABS32.  */
11509     case EM_V800:
11510       return reloc_type == 0x33; /* R_V810_WORD.  */
11511     case EM_VAX:
11512       return reloc_type == 1; /* R_VAX_32.  */
11513     case EM_VISIUM:
11514       return reloc_type == 3;  /* R_VISIUM_32. */
11515     case EM_X86_64:
11516     case EM_L1OM:
11517     case EM_K1OM:
11518       return reloc_type == 10; /* R_X86_64_32.  */
11519     case EM_XC16X:
11520     case EM_C166:
11521       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11522     case EM_XGATE:
11523       return reloc_type == 4; /* R_XGATE_32.  */
11524     case EM_XSTORMY16:
11525       return reloc_type == 1; /* R_XSTROMY16_32.  */
11526     case EM_XTENSA_OLD:
11527     case EM_XTENSA:
11528       return reloc_type == 1; /* R_XTENSA_32.  */
11529     default:
11530       {
11531         static unsigned int prev_warn = 0;
11532
11533         /* Avoid repeating the same warning multiple times.  */
11534         if (prev_warn != elf_header.e_machine)
11535           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11536                  elf_header.e_machine);
11537         prev_warn = elf_header.e_machine;
11538         return FALSE;
11539       }
11540     }
11541 }
11542
11543 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11544    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11545
11546 static bfd_boolean
11547 is_32bit_pcrel_reloc (unsigned int reloc_type)
11548 {
11549   switch (elf_header.e_machine)
11550     {
11551     case EM_386:
11552     case EM_IAMCU:
11553       return reloc_type == 2;  /* R_386_PC32.  */
11554     case EM_68K:
11555       return reloc_type == 4;  /* R_68K_PC32.  */
11556     case EM_AARCH64:
11557       return reloc_type == 261; /* R_AARCH64_PREL32 */
11558     case EM_ADAPTEVA_EPIPHANY:
11559       return reloc_type == 6;
11560     case EM_ALPHA:
11561       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11562     case EM_ARC_COMPACT:
11563     case EM_ARC_COMPACT2:
11564       return reloc_type == 49; /* R_ARC_32_PCREL.  */
11565     case EM_ARM:
11566       return reloc_type == 3;  /* R_ARM_REL32 */
11567     case EM_MICROBLAZE:
11568       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11569     case EM_OR1K:
11570       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11571     case EM_PARISC:
11572       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11573     case EM_PPC:
11574       return reloc_type == 26; /* R_PPC_REL32.  */
11575     case EM_PPC64:
11576       return reloc_type == 26; /* R_PPC64_REL32.  */
11577     case EM_S390_OLD:
11578     case EM_S390:
11579       return reloc_type == 5;  /* R_390_PC32.  */
11580     case EM_SH:
11581       return reloc_type == 2;  /* R_SH_REL32.  */
11582     case EM_SPARC32PLUS:
11583     case EM_SPARCV9:
11584     case EM_SPARC:
11585       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11586     case EM_SPU:
11587       return reloc_type == 13; /* R_SPU_REL32.  */
11588     case EM_TILEGX:
11589       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11590     case EM_TILEPRO:
11591       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11592     case EM_VISIUM:
11593       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11594     case EM_X86_64:
11595     case EM_L1OM:
11596     case EM_K1OM:
11597       return reloc_type == 2;  /* R_X86_64_PC32.  */
11598     case EM_XTENSA_OLD:
11599     case EM_XTENSA:
11600       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11601     default:
11602       /* Do not abort or issue an error message here.  Not all targets use
11603          pc-relative 32-bit relocs in their DWARF debug information and we
11604          have already tested for target coverage in is_32bit_abs_reloc.  A
11605          more helpful warning message will be generated by apply_relocations
11606          anyway, so just return.  */
11607       return FALSE;
11608     }
11609 }
11610
11611 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11612    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11613
11614 static bfd_boolean
11615 is_64bit_abs_reloc (unsigned int reloc_type)
11616 {
11617   switch (elf_header.e_machine)
11618     {
11619     case EM_AARCH64:
11620       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11621     case EM_ALPHA:
11622       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11623     case EM_IA_64:
11624       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11625     case EM_PARISC:
11626       return reloc_type == 80; /* R_PARISC_DIR64.  */
11627     case EM_PPC64:
11628       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11629     case EM_SPARC32PLUS:
11630     case EM_SPARCV9:
11631     case EM_SPARC:
11632       return reloc_type == 54; /* R_SPARC_UA64.  */
11633     case EM_X86_64:
11634     case EM_L1OM:
11635     case EM_K1OM:
11636       return reloc_type == 1; /* R_X86_64_64.  */
11637     case EM_S390_OLD:
11638     case EM_S390:
11639       return reloc_type == 22;  /* R_S390_64.  */
11640     case EM_TILEGX:
11641       return reloc_type == 1; /* R_TILEGX_64.  */
11642     case EM_MIPS:
11643       return reloc_type == 18;  /* R_MIPS_64.  */
11644     default:
11645       return FALSE;
11646     }
11647 }
11648
11649 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11650    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11651
11652 static bfd_boolean
11653 is_64bit_pcrel_reloc (unsigned int reloc_type)
11654 {
11655   switch (elf_header.e_machine)
11656     {
11657     case EM_AARCH64:
11658       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11659     case EM_ALPHA:
11660       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11661     case EM_IA_64:
11662       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11663     case EM_PARISC:
11664       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11665     case EM_PPC64:
11666       return reloc_type == 44; /* R_PPC64_REL64.  */
11667     case EM_SPARC32PLUS:
11668     case EM_SPARCV9:
11669     case EM_SPARC:
11670       return reloc_type == 46; /* R_SPARC_DISP64.  */
11671     case EM_X86_64:
11672     case EM_L1OM:
11673     case EM_K1OM:
11674       return reloc_type == 24; /* R_X86_64_PC64.  */
11675     case EM_S390_OLD:
11676     case EM_S390:
11677       return reloc_type == 23;  /* R_S390_PC64.  */
11678     case EM_TILEGX:
11679       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11680     default:
11681       return FALSE;
11682     }
11683 }
11684
11685 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11686    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11687
11688 static bfd_boolean
11689 is_24bit_abs_reloc (unsigned int reloc_type)
11690 {
11691   switch (elf_header.e_machine)
11692     {
11693     case EM_CYGNUS_MN10200:
11694     case EM_MN10200:
11695       return reloc_type == 4; /* R_MN10200_24.  */
11696     default:
11697       return FALSE;
11698     }
11699 }
11700
11701 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11702    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11703
11704 static bfd_boolean
11705 is_16bit_abs_reloc (unsigned int reloc_type)
11706 {
11707   switch (elf_header.e_machine)
11708     {
11709     case EM_ARC:
11710     case EM_ARC_COMPACT:
11711     case EM_ARC_COMPACT2:
11712       return reloc_type == 2; /* R_ARC_16.  */
11713     case EM_AVR_OLD:
11714     case EM_AVR:
11715       return reloc_type == 4; /* R_AVR_16.  */
11716     case EM_ADAPTEVA_EPIPHANY:
11717       return reloc_type == 5;
11718     case EM_CYGNUS_D10V:
11719     case EM_D10V:
11720       return reloc_type == 3; /* R_D10V_16.  */
11721     case EM_H8S:
11722     case EM_H8_300:
11723     case EM_H8_300H:
11724       return reloc_type == R_H8_DIR16;
11725     case EM_IP2K_OLD:
11726     case EM_IP2K:
11727       return reloc_type == 1; /* R_IP2K_16.  */
11728     case EM_M32C_OLD:
11729     case EM_M32C:
11730       return reloc_type == 1; /* R_M32C_16 */
11731     case EM_MSP430:
11732       if (uses_msp430x_relocs ())
11733         return reloc_type == 2; /* R_MSP430_ABS16.  */
11734     case EM_MSP430_OLD:
11735       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11736     case EM_NDS32:
11737       return reloc_type == 19; /* R_NDS32_RELA.  */
11738     case EM_ALTERA_NIOS2:
11739       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11740     case EM_NIOS32:
11741       return reloc_type == 9; /* R_NIOS_16.  */
11742     case EM_OR1K:
11743       return reloc_type == 2; /* R_OR1K_16.  */
11744     case EM_TI_C6000:
11745       return reloc_type == 2; /* R_C6000_ABS16.  */
11746     case EM_XC16X:
11747     case EM_C166:
11748       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11749     case EM_CYGNUS_MN10200:
11750     case EM_MN10200:
11751       return reloc_type == 2; /* R_MN10200_16.  */
11752     case EM_CYGNUS_MN10300:
11753     case EM_MN10300:
11754       return reloc_type == 2; /* R_MN10300_16.  */
11755     case EM_VISIUM:
11756       return reloc_type == 2; /* R_VISIUM_16. */
11757     case EM_XGATE:
11758       return reloc_type == 3; /* R_XGATE_16.  */
11759     default:
11760       return FALSE;
11761     }
11762 }
11763
11764 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11765    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11766
11767 static bfd_boolean
11768 is_none_reloc (unsigned int reloc_type)
11769 {
11770   switch (elf_header.e_machine)
11771     {
11772     case EM_68K:     /* R_68K_NONE.  */
11773     case EM_386:     /* R_386_NONE.  */
11774     case EM_SPARC32PLUS:
11775     case EM_SPARCV9:
11776     case EM_SPARC:   /* R_SPARC_NONE.  */
11777     case EM_MIPS:    /* R_MIPS_NONE.  */
11778     case EM_PARISC:  /* R_PARISC_NONE.  */
11779     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11780     case EM_ADAPTEVA_EPIPHANY:
11781     case EM_PPC:     /* R_PPC_NONE.  */
11782     case EM_PPC64:   /* R_PPC64_NONE.  */
11783     case EM_ARC:     /* R_ARC_NONE.  */
11784     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
11785     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
11786     case EM_ARM:     /* R_ARM_NONE.  */
11787     case EM_IA_64:   /* R_IA64_NONE.  */
11788     case EM_SH:      /* R_SH_NONE.  */
11789     case EM_S390_OLD:
11790     case EM_S390:    /* R_390_NONE.  */
11791     case EM_CRIS:    /* R_CRIS_NONE.  */
11792     case EM_X86_64:  /* R_X86_64_NONE.  */
11793     case EM_L1OM:    /* R_X86_64_NONE.  */
11794     case EM_K1OM:    /* R_X86_64_NONE.  */
11795     case EM_MN10300: /* R_MN10300_NONE.  */
11796     case EM_FT32:    /* R_FT32_NONE.  */
11797     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11798     case EM_M32R:    /* R_M32R_NONE.  */
11799     case EM_TI_C6000:/* R_C6000_NONE.  */
11800     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11801     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11802     case EM_XC16X:
11803     case EM_C166:    /* R_XC16X_NONE.  */
11804     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11805     case EM_NIOS32:  /* R_NIOS_NONE.  */
11806     case EM_OR1K:    /* R_OR1K_NONE. */
11807       return reloc_type == 0;
11808     case EM_AARCH64:
11809       return reloc_type == 0 || reloc_type == 256;
11810     case EM_NDS32:
11811       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11812               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11813               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11814               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11815               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11816     case EM_XTENSA_OLD:
11817     case EM_XTENSA:
11818       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11819               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11820               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11821               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11822     case EM_METAG:
11823       return reloc_type == 3; /* R_METAG_NONE.  */
11824     }
11825   return FALSE;
11826 }
11827
11828 /* Returns TRUE if there is a relocation against
11829    section NAME at OFFSET bytes.  */
11830
11831 bfd_boolean
11832 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11833 {
11834   Elf_Internal_Rela * relocs;
11835   Elf_Internal_Rela * rp;
11836
11837   if (dsec == NULL || dsec->reloc_info == NULL)
11838     return FALSE;
11839
11840   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11841
11842   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11843     if (rp->r_offset == offset)
11844       return TRUE;
11845
11846    return FALSE;
11847 }
11848
11849 /* Apply relocations to a section.
11850    Note: So far support has been added only for those relocations
11851    which can be found in debug sections.
11852    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11853    loaded relocs.  It is then the caller's responsibility to free them.
11854    FIXME: Add support for more relocations ?  */
11855
11856 static void
11857 apply_relocations (void *                     file,
11858                    const Elf_Internal_Shdr *  section,
11859                    unsigned char *            start,
11860                    bfd_size_type              size,
11861                    void **                     relocs_return,
11862                    unsigned long *            num_relocs_return)
11863 {
11864   Elf_Internal_Shdr * relsec;
11865   unsigned char * end = start + size;
11866
11867   if (relocs_return != NULL)
11868     {
11869       * (Elf_Internal_Rela **) relocs_return = NULL;
11870       * num_relocs_return = 0;
11871     }
11872
11873   if (elf_header.e_type != ET_REL)
11874     return;
11875
11876   /* Find the reloc section associated with the section.  */
11877   for (relsec = section_headers;
11878        relsec < section_headers + elf_header.e_shnum;
11879        ++relsec)
11880     {
11881       bfd_boolean is_rela;
11882       unsigned long num_relocs;
11883       Elf_Internal_Rela * relocs;
11884       Elf_Internal_Rela * rp;
11885       Elf_Internal_Shdr * symsec;
11886       Elf_Internal_Sym * symtab;
11887       unsigned long num_syms;
11888       Elf_Internal_Sym * sym;
11889
11890       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11891           || relsec->sh_info >= elf_header.e_shnum
11892           || section_headers + relsec->sh_info != section
11893           || relsec->sh_size == 0
11894           || relsec->sh_link >= elf_header.e_shnum)
11895         continue;
11896
11897       is_rela = relsec->sh_type == SHT_RELA;
11898
11899       if (is_rela)
11900         {
11901           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11902                                   relsec->sh_size, & relocs, & num_relocs))
11903             return;
11904         }
11905       else
11906         {
11907           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11908                                  relsec->sh_size, & relocs, & num_relocs))
11909             return;
11910         }
11911
11912       /* SH uses RELA but uses in place value instead of the addend field.  */
11913       if (elf_header.e_machine == EM_SH)
11914         is_rela = FALSE;
11915
11916       symsec = section_headers + relsec->sh_link;
11917       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11918
11919       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11920         {
11921           bfd_vma         addend;
11922           unsigned int    reloc_type;
11923           unsigned int    reloc_size;
11924           unsigned char * rloc;
11925           unsigned long   sym_index;
11926
11927           reloc_type = get_reloc_type (rp->r_info);
11928
11929           if (target_specific_reloc_handling (rp, start, symtab))
11930             continue;
11931           else if (is_none_reloc (reloc_type))
11932             continue;
11933           else if (is_32bit_abs_reloc (reloc_type)
11934                    || is_32bit_pcrel_reloc (reloc_type))
11935             reloc_size = 4;
11936           else if (is_64bit_abs_reloc (reloc_type)
11937                    || is_64bit_pcrel_reloc (reloc_type))
11938             reloc_size = 8;
11939           else if (is_24bit_abs_reloc (reloc_type))
11940             reloc_size = 3;
11941           else if (is_16bit_abs_reloc (reloc_type))
11942             reloc_size = 2;
11943           else
11944             {
11945               static unsigned int prev_reloc = 0;
11946               if (reloc_type != prev_reloc)
11947                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11948                       reloc_type, printable_section_name (section));
11949               prev_reloc = reloc_type;
11950               continue;
11951             }
11952
11953           rloc = start + rp->r_offset;
11954           if ((rloc + reloc_size) > end || (rloc < start))
11955             {
11956               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11957                     (unsigned long) rp->r_offset,
11958                     printable_section_name (section));
11959               continue;
11960             }
11961
11962           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11963           if (sym_index >= num_syms)
11964             {
11965               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11966                     sym_index, printable_section_name (section));
11967               continue;
11968             }
11969           sym = symtab + sym_index;
11970
11971           /* If the reloc has a symbol associated with it,
11972              make sure that it is of an appropriate type.
11973
11974              Relocations against symbols without type can happen.
11975              Gcc -feliminate-dwarf2-dups may generate symbols
11976              without type for debug info.
11977
11978              Icc generates relocations against function symbols
11979              instead of local labels.
11980
11981              Relocations against object symbols can happen, eg when
11982              referencing a global array.  For an example of this see
11983              the _clz.o binary in libgcc.a.  */
11984           if (sym != symtab
11985               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11986             {
11987               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11988                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11989                     (long int)(rp - relocs),
11990                     printable_section_name (relsec));
11991               continue;
11992             }
11993
11994           addend = 0;
11995           if (is_rela)
11996             addend += rp->r_addend;
11997           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11998              partial_inplace.  */
11999           if (!is_rela
12000               || (elf_header.e_machine == EM_XTENSA
12001                   && reloc_type == 1)
12002               || ((elf_header.e_machine == EM_PJ
12003                    || elf_header.e_machine == EM_PJ_OLD)
12004                   && reloc_type == 1)
12005               || ((elf_header.e_machine == EM_D30V
12006                    || elf_header.e_machine == EM_CYGNUS_D30V)
12007                   && reloc_type == 12))
12008             addend += byte_get (rloc, reloc_size);
12009
12010           if (is_32bit_pcrel_reloc (reloc_type)
12011               || is_64bit_pcrel_reloc (reloc_type))
12012             {
12013               /* On HPPA, all pc-relative relocations are biased by 8.  */
12014               if (elf_header.e_machine == EM_PARISC)
12015                 addend -= 8;
12016               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12017                         reloc_size);
12018             }
12019           else
12020             byte_put (rloc, addend + sym->st_value, reloc_size);
12021         }
12022
12023       free (symtab);
12024
12025       if (relocs_return)
12026         {
12027           * (Elf_Internal_Rela **) relocs_return = relocs;
12028           * num_relocs_return = num_relocs;
12029         }
12030       else
12031         free (relocs);
12032
12033       break;
12034     }
12035 }
12036
12037 #ifdef SUPPORT_DISASSEMBLY
12038 static int
12039 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12040 {
12041   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12042
12043   /* FIXME: XXX -- to be done --- XXX */
12044
12045   return 1;
12046 }
12047 #endif
12048
12049 /* Reads in the contents of SECTION from FILE, returning a pointer
12050    to a malloc'ed buffer or NULL if something went wrong.  */
12051
12052 static char *
12053 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12054 {
12055   bfd_size_type num_bytes;
12056
12057   num_bytes = section->sh_size;
12058
12059   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12060     {
12061       printf (_("\nSection '%s' has no data to dump.\n"),
12062               printable_section_name (section));
12063       return NULL;
12064     }
12065
12066   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12067                              _("section contents"));
12068 }
12069
12070 /* Uncompresses a section that was compressed using zlib, in place.  */
12071
12072 static bfd_boolean
12073 uncompress_section_contents (unsigned char **buffer,
12074                              dwarf_size_type uncompressed_size,
12075                              dwarf_size_type *size)
12076 {
12077   dwarf_size_type compressed_size = *size;
12078   unsigned char * compressed_buffer = *buffer;
12079   unsigned char * uncompressed_buffer;
12080   z_stream strm;
12081   int rc;
12082
12083   /* It is possible the section consists of several compressed
12084      buffers concatenated together, so we uncompress in a loop.  */
12085   /* PR 18313: The state field in the z_stream structure is supposed
12086      to be invisible to the user (ie us), but some compilers will
12087      still complain about it being used without initialisation.  So
12088      we first zero the entire z_stream structure and then set the fields
12089      that we need.  */
12090   memset (& strm, 0, sizeof strm);
12091   strm.avail_in = compressed_size;
12092   strm.next_in = (Bytef *) compressed_buffer;
12093   strm.avail_out = uncompressed_size;
12094   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12095
12096   rc = inflateInit (& strm);
12097   while (strm.avail_in > 0)
12098     {
12099       if (rc != Z_OK)
12100         goto fail;
12101       strm.next_out = ((Bytef *) uncompressed_buffer
12102                        + (uncompressed_size - strm.avail_out));
12103       rc = inflate (&strm, Z_FINISH);
12104       if (rc != Z_STREAM_END)
12105         goto fail;
12106       rc = inflateReset (& strm);
12107     }
12108   rc = inflateEnd (& strm);
12109   if (rc != Z_OK
12110       || strm.avail_out != 0)
12111     goto fail;
12112
12113   *buffer = uncompressed_buffer;
12114   *size = uncompressed_size;
12115   return TRUE;
12116
12117  fail:
12118   free (uncompressed_buffer);
12119   /* Indicate decompression failure.  */
12120   *buffer = NULL;
12121   return FALSE;
12122 }
12123
12124 static void
12125 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12126 {
12127   Elf_Internal_Shdr *  relsec;
12128   bfd_size_type        num_bytes;
12129   unsigned char *      data;
12130   unsigned char *      end;
12131   unsigned char *      real_start;
12132   unsigned char *      start;
12133   bfd_boolean          some_strings_shown;
12134
12135   real_start = start = (unsigned char *) get_section_contents (section,
12136                                                                file);
12137   if (start == NULL)
12138     return;
12139   num_bytes = section->sh_size;
12140
12141   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12142
12143   if (decompress_dumps)
12144     {
12145       dwarf_size_type new_size = num_bytes;
12146       dwarf_size_type uncompressed_size = 0;
12147
12148       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12149         {
12150           Elf_Internal_Chdr chdr;
12151           unsigned int compression_header_size
12152             = get_compression_header (& chdr, (unsigned char *) start);
12153
12154           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12155             {
12156               warn (_("section '%s' has unsupported compress type: %d\n"),
12157                     printable_section_name (section), chdr.ch_type);
12158               return;
12159             }
12160           else if (chdr.ch_addralign != section->sh_addralign)
12161             {
12162               warn (_("compressed section '%s' is corrupted\n"),
12163                     printable_section_name (section));
12164               return;
12165             }
12166           uncompressed_size = chdr.ch_size;
12167           start += compression_header_size;
12168           new_size -= compression_header_size;
12169         }
12170       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12171         {
12172           /* Read the zlib header.  In this case, it should be "ZLIB"
12173              followed by the uncompressed section size, 8 bytes in
12174              big-endian order.  */
12175           uncompressed_size = start[4]; uncompressed_size <<= 8;
12176           uncompressed_size += start[5]; uncompressed_size <<= 8;
12177           uncompressed_size += start[6]; uncompressed_size <<= 8;
12178           uncompressed_size += start[7]; uncompressed_size <<= 8;
12179           uncompressed_size += start[8]; uncompressed_size <<= 8;
12180           uncompressed_size += start[9]; uncompressed_size <<= 8;
12181           uncompressed_size += start[10]; uncompressed_size <<= 8;
12182           uncompressed_size += start[11];
12183           start += 12;
12184           new_size -= 12;
12185         }
12186
12187       if (uncompressed_size
12188           && uncompress_section_contents (& start,
12189                                           uncompressed_size, & new_size))
12190         num_bytes = new_size;
12191     }
12192
12193   /* If the section being dumped has relocations against it the user might
12194      be expecting these relocations to have been applied.  Check for this
12195      case and issue a warning message in order to avoid confusion.
12196      FIXME: Maybe we ought to have an option that dumps a section with
12197      relocs applied ?  */
12198   for (relsec = section_headers;
12199        relsec < section_headers + elf_header.e_shnum;
12200        ++relsec)
12201     {
12202       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12203           || relsec->sh_info >= elf_header.e_shnum
12204           || section_headers + relsec->sh_info != section
12205           || relsec->sh_size == 0
12206           || relsec->sh_link >= elf_header.e_shnum)
12207         continue;
12208
12209       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12210       break;
12211     }
12212
12213   data = start;
12214   end  = start + num_bytes;
12215   some_strings_shown = FALSE;
12216
12217   while (data < end)
12218     {
12219       while (!ISPRINT (* data))
12220         if (++ data >= end)
12221           break;
12222
12223       if (data < end)
12224         {
12225           size_t maxlen = end - data;
12226
12227 #ifndef __MSVCRT__
12228           /* PR 11128: Use two separate invocations in order to work
12229              around bugs in the Solaris 8 implementation of printf.  */
12230           printf ("  [%6tx]  ", data - start);
12231 #else
12232           printf ("  [%6Ix]  ", (size_t) (data - start));
12233 #endif
12234           if (maxlen > 0)
12235             {
12236               print_symbol ((int) maxlen, (const char *) data);
12237               putchar ('\n');
12238               data += strnlen ((const char *) data, maxlen);
12239             }
12240           else
12241             {
12242               printf (_("<corrupt>\n"));
12243               data = end;
12244             }
12245           some_strings_shown = TRUE;
12246         }
12247     }
12248
12249   if (! some_strings_shown)
12250     printf (_("  No strings found in this section."));
12251
12252   free (real_start);
12253
12254   putchar ('\n');
12255 }
12256
12257 static void
12258 dump_section_as_bytes (Elf_Internal_Shdr * section,
12259                        FILE * file,
12260                        bfd_boolean relocate)
12261 {
12262   Elf_Internal_Shdr * relsec;
12263   bfd_size_type       bytes;
12264   bfd_size_type       section_size;
12265   bfd_vma             addr;
12266   unsigned char *     data;
12267   unsigned char *     real_start;
12268   unsigned char *     start;
12269
12270   real_start = start = (unsigned char *) get_section_contents (section, file);
12271   if (start == NULL)
12272     return;
12273   section_size = section->sh_size;
12274
12275   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12276
12277   if (decompress_dumps)
12278     {
12279       dwarf_size_type new_size = section_size;
12280       dwarf_size_type uncompressed_size = 0;
12281
12282       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12283         {
12284           Elf_Internal_Chdr chdr;
12285           unsigned int compression_header_size
12286             = get_compression_header (& chdr, start);
12287
12288           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12289             {
12290               warn (_("section '%s' has unsupported compress type: %d\n"),
12291                     printable_section_name (section), chdr.ch_type);
12292               return;
12293             }
12294           else if (chdr.ch_addralign != section->sh_addralign)
12295             {
12296               warn (_("compressed section '%s' is corrupted\n"),
12297                     printable_section_name (section));
12298               return;
12299             }
12300           uncompressed_size = chdr.ch_size;
12301           start += compression_header_size;
12302           new_size -= compression_header_size;
12303         }
12304       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12305         {
12306           /* Read the zlib header.  In this case, it should be "ZLIB"
12307              followed by the uncompressed section size, 8 bytes in
12308              big-endian order.  */
12309           uncompressed_size = start[4]; uncompressed_size <<= 8;
12310           uncompressed_size += start[5]; uncompressed_size <<= 8;
12311           uncompressed_size += start[6]; uncompressed_size <<= 8;
12312           uncompressed_size += start[7]; uncompressed_size <<= 8;
12313           uncompressed_size += start[8]; uncompressed_size <<= 8;
12314           uncompressed_size += start[9]; uncompressed_size <<= 8;
12315           uncompressed_size += start[10]; uncompressed_size <<= 8;
12316           uncompressed_size += start[11];
12317           start += 12;
12318           new_size -= 12;
12319         }
12320
12321       if (uncompressed_size
12322           && uncompress_section_contents (& start, uncompressed_size,
12323                                           & new_size))
12324         section_size = new_size;
12325     }
12326
12327   if (relocate)
12328     {
12329       apply_relocations (file, section, start, section_size, NULL, NULL);
12330     }
12331   else
12332     {
12333       /* If the section being dumped has relocations against it the user might
12334          be expecting these relocations to have been applied.  Check for this
12335          case and issue a warning message in order to avoid confusion.
12336          FIXME: Maybe we ought to have an option that dumps a section with
12337          relocs applied ?  */
12338       for (relsec = section_headers;
12339            relsec < section_headers + elf_header.e_shnum;
12340            ++relsec)
12341         {
12342           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12343               || relsec->sh_info >= elf_header.e_shnum
12344               || section_headers + relsec->sh_info != section
12345               || relsec->sh_size == 0
12346               || relsec->sh_link >= elf_header.e_shnum)
12347             continue;
12348
12349           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12350           break;
12351         }
12352     }
12353
12354   addr = section->sh_addr;
12355   bytes = section_size;
12356   data = start;
12357
12358   while (bytes)
12359     {
12360       int j;
12361       int k;
12362       int lbytes;
12363
12364       lbytes = (bytes > 16 ? 16 : bytes);
12365
12366       printf ("  0x%8.8lx ", (unsigned long) addr);
12367
12368       for (j = 0; j < 16; j++)
12369         {
12370           if (j < lbytes)
12371             printf ("%2.2x", data[j]);
12372           else
12373             printf ("  ");
12374
12375           if ((j & 3) == 3)
12376             printf (" ");
12377         }
12378
12379       for (j = 0; j < lbytes; j++)
12380         {
12381           k = data[j];
12382           if (k >= ' ' && k < 0x7f)
12383             printf ("%c", k);
12384           else
12385             printf (".");
12386         }
12387
12388       putchar ('\n');
12389
12390       data  += lbytes;
12391       addr  += lbytes;
12392       bytes -= lbytes;
12393     }
12394
12395   free (real_start);
12396
12397   putchar ('\n');
12398 }
12399
12400 static int
12401 load_specific_debug_section (enum dwarf_section_display_enum debug,
12402                              const Elf_Internal_Shdr * sec, void * file)
12403 {
12404   struct dwarf_section * section = &debug_displays [debug].section;
12405   char buf [64];
12406
12407   /* If it is already loaded, do nothing.  */
12408   if (section->start != NULL)
12409     return 1;
12410
12411   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12412   section->address = sec->sh_addr;
12413   section->user_data = NULL;
12414   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12415                                                sec->sh_offset, 1,
12416                                                sec->sh_size, buf);
12417   if (section->start == NULL)
12418     section->size = 0;
12419   else
12420     {
12421       unsigned char *start = section->start;
12422       dwarf_size_type size = sec->sh_size;
12423       dwarf_size_type uncompressed_size = 0;
12424
12425       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12426         {
12427           Elf_Internal_Chdr chdr;
12428           unsigned int compression_header_size
12429             = get_compression_header (&chdr, start);
12430           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12431             {
12432               warn (_("section '%s' has unsupported compress type: %d\n"),
12433                     section->name, chdr.ch_type);
12434               return 0;
12435             }
12436           else if (chdr.ch_addralign != sec->sh_addralign)
12437             {
12438               warn (_("compressed section '%s' is corrupted\n"),
12439                     section->name);
12440               return 0;
12441             }
12442           uncompressed_size = chdr.ch_size;
12443           start += compression_header_size;
12444           size -= compression_header_size;
12445         }
12446       else if (size > 12 && streq ((char *) start, "ZLIB"))
12447         {
12448           /* Read the zlib header.  In this case, it should be "ZLIB"
12449              followed by the uncompressed section size, 8 bytes in
12450              big-endian order.  */
12451           uncompressed_size = start[4]; uncompressed_size <<= 8;
12452           uncompressed_size += start[5]; uncompressed_size <<= 8;
12453           uncompressed_size += start[6]; uncompressed_size <<= 8;
12454           uncompressed_size += start[7]; uncompressed_size <<= 8;
12455           uncompressed_size += start[8]; uncompressed_size <<= 8;
12456           uncompressed_size += start[9]; uncompressed_size <<= 8;
12457           uncompressed_size += start[10]; uncompressed_size <<= 8;
12458           uncompressed_size += start[11];
12459           start += 12;
12460           size -= 12;
12461         }
12462
12463       if (uncompressed_size
12464           && uncompress_section_contents (&start, uncompressed_size,
12465                                           &size))
12466         {
12467           /* Free the compressed buffer, update the section buffer
12468              and the section size if uncompress is successful.  */
12469           free (section->start);
12470           section->start = start;
12471         }
12472       section->size = size;
12473     }
12474
12475   if (section->start == NULL)
12476     return 0;
12477
12478   if (debug_displays [debug].relocate)
12479     apply_relocations ((FILE *) file, sec, section->start, section->size,
12480                        & section->reloc_info, & section->num_relocs);
12481   else
12482     {
12483       section->reloc_info = NULL;
12484       section->num_relocs = 0;
12485     }
12486
12487   return 1;
12488 }
12489
12490 /* If this is not NULL, load_debug_section will only look for sections
12491    within the list of sections given here.  */
12492 unsigned int *section_subset = NULL;
12493
12494 int
12495 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12496 {
12497   struct dwarf_section * section = &debug_displays [debug].section;
12498   Elf_Internal_Shdr * sec;
12499
12500   /* Locate the debug section.  */
12501   sec = find_section_in_set (section->uncompressed_name, section_subset);
12502   if (sec != NULL)
12503     section->name = section->uncompressed_name;
12504   else
12505     {
12506       sec = find_section_in_set (section->compressed_name, section_subset);
12507       if (sec != NULL)
12508         section->name = section->compressed_name;
12509     }
12510   if (sec == NULL)
12511     return 0;
12512
12513   /* If we're loading from a subset of sections, and we've loaded
12514      a section matching this name before, it's likely that it's a
12515      different one.  */
12516   if (section_subset != NULL)
12517     free_debug_section (debug);
12518
12519   return load_specific_debug_section (debug, sec, (FILE *) file);
12520 }
12521
12522 void
12523 free_debug_section (enum dwarf_section_display_enum debug)
12524 {
12525   struct dwarf_section * section = &debug_displays [debug].section;
12526
12527   if (section->start == NULL)
12528     return;
12529
12530   free ((char *) section->start);
12531   section->start = NULL;
12532   section->address = 0;
12533   section->size = 0;
12534 }
12535
12536 static int
12537 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12538 {
12539   char * name = SECTION_NAME (section);
12540   const char * print_name = printable_section_name (section);
12541   bfd_size_type length;
12542   int result = 1;
12543   int i;
12544
12545   length = section->sh_size;
12546   if (length == 0)
12547     {
12548       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12549       return 0;
12550     }
12551   if (section->sh_type == SHT_NOBITS)
12552     {
12553       /* There is no point in dumping the contents of a debugging section
12554          which has the NOBITS type - the bits in the file will be random.
12555          This can happen when a file containing a .eh_frame section is
12556          stripped with the --only-keep-debug command line option.  */
12557       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12558               print_name);
12559       return 0;
12560     }
12561
12562   if (const_strneq (name, ".gnu.linkonce.wi."))
12563     name = ".debug_info";
12564
12565   /* See if we know how to display the contents of this section.  */
12566   for (i = 0; i < max; i++)
12567     if (streq (debug_displays[i].section.uncompressed_name, name)
12568         || (i == line && const_strneq (name, ".debug_line."))
12569         || streq (debug_displays[i].section.compressed_name, name))
12570       {
12571         struct dwarf_section * sec = &debug_displays [i].section;
12572         int secondary = (section != find_section (name));
12573
12574         if (secondary)
12575           free_debug_section ((enum dwarf_section_display_enum) i);
12576
12577         if (i == line && const_strneq (name, ".debug_line."))
12578           sec->name = name;
12579         else if (streq (sec->uncompressed_name, name))
12580           sec->name = sec->uncompressed_name;
12581         else
12582           sec->name = sec->compressed_name;
12583         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12584                                          section, file))
12585           {
12586             /* If this debug section is part of a CU/TU set in a .dwp file,
12587                restrict load_debug_section to the sections in that set.  */
12588             section_subset = find_cu_tu_set (file, shndx);
12589
12590             result &= debug_displays[i].display (sec, file);
12591
12592             section_subset = NULL;
12593
12594             if (secondary || (i != info && i != abbrev))
12595               free_debug_section ((enum dwarf_section_display_enum) i);
12596           }
12597
12598         break;
12599       }
12600
12601   if (i == max)
12602     {
12603       printf (_("Unrecognized debug section: %s\n"), print_name);
12604       result = 0;
12605     }
12606
12607   return result;
12608 }
12609
12610 /* Set DUMP_SECTS for all sections where dumps were requested
12611    based on section name.  */
12612
12613 static void
12614 initialise_dumps_byname (void)
12615 {
12616   struct dump_list_entry * cur;
12617
12618   for (cur = dump_sects_byname; cur; cur = cur->next)
12619     {
12620       unsigned int i;
12621       int any;
12622
12623       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12624         if (streq (SECTION_NAME (section_headers + i), cur->name))
12625           {
12626             request_dump_bynumber (i, cur->type);
12627             any = 1;
12628           }
12629
12630       if (!any)
12631         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12632               cur->name);
12633     }
12634 }
12635
12636 static void
12637 process_section_contents (FILE * file)
12638 {
12639   Elf_Internal_Shdr * section;
12640   unsigned int i;
12641
12642   if (! do_dump)
12643     return;
12644
12645   initialise_dumps_byname ();
12646
12647   for (i = 0, section = section_headers;
12648        i < elf_header.e_shnum && i < num_dump_sects;
12649        i++, section++)
12650     {
12651 #ifdef SUPPORT_DISASSEMBLY
12652       if (dump_sects[i] & DISASS_DUMP)
12653         disassemble_section (section, file);
12654 #endif
12655       if (dump_sects[i] & HEX_DUMP)
12656         dump_section_as_bytes (section, file, FALSE);
12657
12658       if (dump_sects[i] & RELOC_DUMP)
12659         dump_section_as_bytes (section, file, TRUE);
12660
12661       if (dump_sects[i] & STRING_DUMP)
12662         dump_section_as_strings (section, file);
12663
12664       if (dump_sects[i] & DEBUG_DUMP)
12665         display_debug_section (i, section, file);
12666     }
12667
12668   /* Check to see if the user requested a
12669      dump of a section that does not exist.  */
12670   while (i++ < num_dump_sects)
12671     if (dump_sects[i])
12672       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12673 }
12674
12675 static void
12676 process_mips_fpe_exception (int mask)
12677 {
12678   if (mask)
12679     {
12680       int first = 1;
12681       if (mask & OEX_FPU_INEX)
12682         fputs ("INEX", stdout), first = 0;
12683       if (mask & OEX_FPU_UFLO)
12684         printf ("%sUFLO", first ? "" : "|"), first = 0;
12685       if (mask & OEX_FPU_OFLO)
12686         printf ("%sOFLO", first ? "" : "|"), first = 0;
12687       if (mask & OEX_FPU_DIV0)
12688         printf ("%sDIV0", first ? "" : "|"), first = 0;
12689       if (mask & OEX_FPU_INVAL)
12690         printf ("%sINVAL", first ? "" : "|");
12691     }
12692   else
12693     fputs ("0", stdout);
12694 }
12695
12696 /* Display's the value of TAG at location P.  If TAG is
12697    greater than 0 it is assumed to be an unknown tag, and
12698    a message is printed to this effect.  Otherwise it is
12699    assumed that a message has already been printed.
12700
12701    If the bottom bit of TAG is set it assumed to have a
12702    string value, otherwise it is assumed to have an integer
12703    value.
12704
12705    Returns an updated P pointing to the first unread byte
12706    beyond the end of TAG's value.
12707
12708    Reads at or beyond END will not be made.  */
12709
12710 static unsigned char *
12711 display_tag_value (int tag,
12712                    unsigned char * p,
12713                    const unsigned char * const end)
12714 {
12715   unsigned long val;
12716
12717   if (tag > 0)
12718     printf ("  Tag_unknown_%d: ", tag);
12719
12720   if (p >= end)
12721     {
12722       warn (_("<corrupt tag>\n"));
12723     }
12724   else if (tag & 1)
12725     {
12726       /* PR 17531 file: 027-19978-0.004.  */
12727       size_t maxlen = (end - p) - 1;
12728
12729       putchar ('"');
12730       if (maxlen > 0)
12731         {
12732           print_symbol ((int) maxlen, (const char *) p);
12733           p += strnlen ((char *) p, maxlen) + 1;
12734         }
12735       else
12736         {
12737           printf (_("<corrupt string tag>"));
12738           p = (unsigned char *) end;
12739         }
12740       printf ("\"\n");
12741     }
12742   else
12743     {
12744       unsigned int len;
12745
12746       val = read_uleb128 (p, &len, end);
12747       p += len;
12748       printf ("%ld (0x%lx)\n", val, val);
12749     }
12750
12751   assert (p <= end);
12752   return p;
12753 }
12754
12755 /* ARM EABI attributes section.  */
12756 typedef struct
12757 {
12758   unsigned int tag;
12759   const char * name;
12760   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12761   unsigned int type;
12762   const char ** table;
12763 } arm_attr_public_tag;
12764
12765 static const char * arm_attr_tag_CPU_arch[] =
12766   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12767    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12768    "v8-M.mainline"};
12769 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12770 static const char * arm_attr_tag_THUMB_ISA_use[] =
12771   {"No", "Thumb-1", "Thumb-2", "Yes"};
12772 static const char * arm_attr_tag_FP_arch[] =
12773   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12774    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12775 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12776 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12777   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12778 static const char * arm_attr_tag_PCS_config[] =
12779   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12780    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12781 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12782   {"V6", "SB", "TLS", "Unused"};
12783 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12784   {"Absolute", "PC-relative", "SB-relative", "None"};
12785 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12786   {"Absolute", "PC-relative", "None"};
12787 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12788   {"None", "direct", "GOT-indirect"};
12789 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12790   {"None", "??? 1", "2", "??? 3", "4"};
12791 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12792 static const char * arm_attr_tag_ABI_FP_denormal[] =
12793   {"Unused", "Needed", "Sign only"};
12794 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12795 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12796 static const char * arm_attr_tag_ABI_FP_number_model[] =
12797   {"Unused", "Finite", "RTABI", "IEEE 754"};
12798 static const char * arm_attr_tag_ABI_enum_size[] =
12799   {"Unused", "small", "int", "forced to int"};
12800 static const char * arm_attr_tag_ABI_HardFP_use[] =
12801   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12802 static const char * arm_attr_tag_ABI_VFP_args[] =
12803   {"AAPCS", "VFP registers", "custom", "compatible"};
12804 static const char * arm_attr_tag_ABI_WMMX_args[] =
12805   {"AAPCS", "WMMX registers", "custom"};
12806 static const char * arm_attr_tag_ABI_optimization_goals[] =
12807   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12808     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12809 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12810   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12811     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12812 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12813 static const char * arm_attr_tag_FP_HP_extension[] =
12814   {"Not Allowed", "Allowed"};
12815 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12816   {"None", "IEEE 754", "Alternative Format"};
12817 static const char * arm_attr_tag_MPextension_use[] =
12818   {"Not Allowed", "Allowed"};
12819 static const char * arm_attr_tag_DIV_use[] =
12820   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12821     "Allowed in v7-A with integer division extension"};
12822 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12823 static const char * arm_attr_tag_Virtualization_use[] =
12824   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12825     "TrustZone and Virtualization Extensions"};
12826 static const char * arm_attr_tag_MPextension_use_legacy[] =
12827   {"Not Allowed", "Allowed"};
12828
12829 #define LOOKUP(id, name) \
12830   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12831 static arm_attr_public_tag arm_attr_public_tags[] =
12832 {
12833   {4, "CPU_raw_name", 1, NULL},
12834   {5, "CPU_name", 1, NULL},
12835   LOOKUP(6, CPU_arch),
12836   {7, "CPU_arch_profile", 0, NULL},
12837   LOOKUP(8, ARM_ISA_use),
12838   LOOKUP(9, THUMB_ISA_use),
12839   LOOKUP(10, FP_arch),
12840   LOOKUP(11, WMMX_arch),
12841   LOOKUP(12, Advanced_SIMD_arch),
12842   LOOKUP(13, PCS_config),
12843   LOOKUP(14, ABI_PCS_R9_use),
12844   LOOKUP(15, ABI_PCS_RW_data),
12845   LOOKUP(16, ABI_PCS_RO_data),
12846   LOOKUP(17, ABI_PCS_GOT_use),
12847   LOOKUP(18, ABI_PCS_wchar_t),
12848   LOOKUP(19, ABI_FP_rounding),
12849   LOOKUP(20, ABI_FP_denormal),
12850   LOOKUP(21, ABI_FP_exceptions),
12851   LOOKUP(22, ABI_FP_user_exceptions),
12852   LOOKUP(23, ABI_FP_number_model),
12853   {24, "ABI_align_needed", 0, NULL},
12854   {25, "ABI_align_preserved", 0, NULL},
12855   LOOKUP(26, ABI_enum_size),
12856   LOOKUP(27, ABI_HardFP_use),
12857   LOOKUP(28, ABI_VFP_args),
12858   LOOKUP(29, ABI_WMMX_args),
12859   LOOKUP(30, ABI_optimization_goals),
12860   LOOKUP(31, ABI_FP_optimization_goals),
12861   {32, "compatibility", 0, NULL},
12862   LOOKUP(34, CPU_unaligned_access),
12863   LOOKUP(36, FP_HP_extension),
12864   LOOKUP(38, ABI_FP_16bit_format),
12865   LOOKUP(42, MPextension_use),
12866   LOOKUP(44, DIV_use),
12867   {64, "nodefaults", 0, NULL},
12868   {65, "also_compatible_with", 0, NULL},
12869   LOOKUP(66, T2EE_use),
12870   {67, "conformance", 1, NULL},
12871   LOOKUP(68, Virtualization_use),
12872   LOOKUP(70, MPextension_use_legacy)
12873 };
12874 #undef LOOKUP
12875
12876 static unsigned char *
12877 display_arm_attribute (unsigned char * p,
12878                        const unsigned char * const end)
12879 {
12880   unsigned int tag;
12881   unsigned int len;
12882   unsigned int val;
12883   arm_attr_public_tag * attr;
12884   unsigned i;
12885   unsigned int type;
12886
12887   tag = read_uleb128 (p, &len, end);
12888   p += len;
12889   attr = NULL;
12890   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12891     {
12892       if (arm_attr_public_tags[i].tag == tag)
12893         {
12894           attr = &arm_attr_public_tags[i];
12895           break;
12896         }
12897     }
12898
12899   if (attr)
12900     {
12901       printf ("  Tag_%s: ", attr->name);
12902       switch (attr->type)
12903         {
12904         case 0:
12905           switch (tag)
12906             {
12907             case 7: /* Tag_CPU_arch_profile.  */
12908               val = read_uleb128 (p, &len, end);
12909               p += len;
12910               switch (val)
12911                 {
12912                 case 0: printf (_("None\n")); break;
12913                 case 'A': printf (_("Application\n")); break;
12914                 case 'R': printf (_("Realtime\n")); break;
12915                 case 'M': printf (_("Microcontroller\n")); break;
12916                 case 'S': printf (_("Application or Realtime\n")); break;
12917                 default: printf ("??? (%d)\n", val); break;
12918                 }
12919               break;
12920
12921             case 24: /* Tag_align_needed.  */
12922               val = read_uleb128 (p, &len, end);
12923               p += len;
12924               switch (val)
12925                 {
12926                 case 0: printf (_("None\n")); break;
12927                 case 1: printf (_("8-byte\n")); break;
12928                 case 2: printf (_("4-byte\n")); break;
12929                 case 3: printf ("??? 3\n"); break;
12930                 default:
12931                   if (val <= 12)
12932                     printf (_("8-byte and up to %d-byte extended\n"),
12933                             1 << val);
12934                   else
12935                     printf ("??? (%d)\n", val);
12936                   break;
12937                 }
12938               break;
12939
12940             case 25: /* Tag_align_preserved.  */
12941               val = read_uleb128 (p, &len, end);
12942               p += len;
12943               switch (val)
12944                 {
12945                 case 0: printf (_("None\n")); break;
12946                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12947                 case 2: printf (_("8-byte\n")); break;
12948                 case 3: printf ("??? 3\n"); break;
12949                 default:
12950                   if (val <= 12)
12951                     printf (_("8-byte and up to %d-byte extended\n"),
12952                             1 << val);
12953                   else
12954                     printf ("??? (%d)\n", val);
12955                   break;
12956                 }
12957               break;
12958
12959             case 32: /* Tag_compatibility.  */
12960               {
12961                 val = read_uleb128 (p, &len, end);
12962                 p += len;
12963                 printf (_("flag = %d, vendor = "), val);
12964                 if (p < end - 1)
12965                   {
12966                     size_t maxlen = (end - p) - 1;
12967
12968                     print_symbol ((int) maxlen, (const char *) p);
12969                     p += strnlen ((char *) p, maxlen) + 1;
12970                   }
12971                 else
12972                   {
12973                     printf (_("<corrupt>"));
12974                     p = (unsigned char *) end;
12975                   }
12976                 putchar ('\n');
12977               }
12978               break;
12979
12980             case 64: /* Tag_nodefaults.  */
12981               /* PR 17531: file: 001-505008-0.01.  */
12982               if (p < end)
12983                 p++;
12984               printf (_("True\n"));
12985               break;
12986
12987             case 65: /* Tag_also_compatible_with.  */
12988               val = read_uleb128 (p, &len, end);
12989               p += len;
12990               if (val == 6 /* Tag_CPU_arch.  */)
12991                 {
12992                   val = read_uleb128 (p, &len, end);
12993                   p += len;
12994                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12995                     printf ("??? (%d)\n", val);
12996                   else
12997                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12998                 }
12999               else
13000                 printf ("???\n");
13001               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13002                 ;
13003               break;
13004
13005             default:
13006               printf (_("<unknown: %d>\n"), tag);
13007               break;
13008             }
13009           return p;
13010
13011         case 1:
13012           return display_tag_value (-1, p, end);
13013         case 2:
13014           return display_tag_value (0, p, end);
13015
13016         default:
13017           assert (attr->type & 0x80);
13018           val = read_uleb128 (p, &len, end);
13019           p += len;
13020           type = attr->type & 0x7f;
13021           if (val >= type)
13022             printf ("??? (%d)\n", val);
13023           else
13024             printf ("%s\n", attr->table[val]);
13025           return p;
13026         }
13027     }
13028
13029   return display_tag_value (tag, p, end);
13030 }
13031
13032 static unsigned char *
13033 display_gnu_attribute (unsigned char * p,
13034                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13035                        const unsigned char * const end)
13036 {
13037   int tag;
13038   unsigned int len;
13039   int val;
13040
13041   tag = read_uleb128 (p, &len, end);
13042   p += len;
13043
13044   /* Tag_compatibility is the only generic GNU attribute defined at
13045      present.  */
13046   if (tag == 32)
13047     {
13048       val = read_uleb128 (p, &len, end);
13049       p += len;
13050
13051       printf (_("flag = %d, vendor = "), val);
13052       if (p == end)
13053         {
13054           printf (_("<corrupt>\n"));
13055           warn (_("corrupt vendor attribute\n"));
13056         }
13057       else
13058         {
13059           if (p < end - 1)
13060             {
13061               size_t maxlen = (end - p) - 1;
13062
13063               print_symbol ((int) maxlen, (const char *) p);
13064               p += strnlen ((char *) p, maxlen) + 1;
13065             }
13066           else
13067             {
13068               printf (_("<corrupt>"));
13069               p = (unsigned char *) end;
13070             }
13071           putchar ('\n');
13072         }
13073       return p;
13074     }
13075
13076   if ((tag & 2) == 0 && display_proc_gnu_attribute)
13077     return display_proc_gnu_attribute (p, tag, end);
13078
13079   return display_tag_value (tag, p, end);
13080 }
13081
13082 static unsigned char *
13083 display_power_gnu_attribute (unsigned char * p,
13084                              int tag,
13085                              const unsigned char * const end)
13086 {
13087   unsigned int len;
13088   int val;
13089
13090   if (tag == Tag_GNU_Power_ABI_FP)
13091     {
13092       val = read_uleb128 (p, &len, end);
13093       p += len;
13094       printf ("  Tag_GNU_Power_ABI_FP: ");
13095
13096       switch (val)
13097         {
13098         case 0:
13099           printf (_("Hard or soft float\n"));
13100           break;
13101         case 1:
13102           printf (_("Hard float\n"));
13103           break;
13104         case 2:
13105           printf (_("Soft float\n"));
13106           break;
13107         case 3:
13108           printf (_("Single-precision hard float\n"));
13109           break;
13110         default:
13111           printf ("??? (%d)\n", val);
13112           break;
13113         }
13114       return p;
13115    }
13116
13117   if (tag == Tag_GNU_Power_ABI_Vector)
13118     {
13119       val = read_uleb128 (p, &len, end);
13120       p += len;
13121       printf ("  Tag_GNU_Power_ABI_Vector: ");
13122       switch (val)
13123         {
13124         case 0:
13125           printf (_("Any\n"));
13126           break;
13127         case 1:
13128           printf (_("Generic\n"));
13129           break;
13130         case 2:
13131           printf ("AltiVec\n");
13132           break;
13133         case 3:
13134           printf ("SPE\n");
13135           break;
13136         default:
13137           printf ("??? (%d)\n", val);
13138           break;
13139         }
13140       return p;
13141    }
13142
13143   if (tag == Tag_GNU_Power_ABI_Struct_Return)
13144     {
13145       if (p == end)
13146         {
13147           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13148           return p;
13149         }
13150
13151       val = read_uleb128 (p, &len, end);
13152       p += len;
13153       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13154       switch (val)
13155        {
13156        case 0:
13157          printf (_("Any\n"));
13158          break;
13159        case 1:
13160          printf ("r3/r4\n");
13161          break;
13162        case 2:
13163          printf (_("Memory\n"));
13164          break;
13165        default:
13166          printf ("??? (%d)\n", val);
13167          break;
13168        }
13169       return p;
13170     }
13171
13172   return display_tag_value (tag & 1, p, end);
13173 }
13174
13175 static unsigned char *
13176 display_s390_gnu_attribute (unsigned char * p,
13177                             int tag,
13178                             const unsigned char * const end)
13179 {
13180   unsigned int len;
13181   int val;
13182
13183   if (tag == Tag_GNU_S390_ABI_Vector)
13184     {
13185       val = read_uleb128 (p, &len, end);
13186       p += len;
13187       printf ("  Tag_GNU_S390_ABI_Vector: ");
13188
13189       switch (val)
13190         {
13191         case 0:
13192           printf (_("any\n"));
13193           break;
13194         case 1:
13195           printf (_("software\n"));
13196           break;
13197         case 2:
13198           printf (_("hardware\n"));
13199           break;
13200         default:
13201           printf ("??? (%d)\n", val);
13202           break;
13203         }
13204       return p;
13205    }
13206
13207   return display_tag_value (tag & 1, p, end);
13208 }
13209
13210 static void
13211 display_sparc_hwcaps (int mask)
13212 {
13213   if (mask)
13214     {
13215       int first = 1;
13216
13217       if (mask & ELF_SPARC_HWCAP_MUL32)
13218         fputs ("mul32", stdout), first = 0;
13219       if (mask & ELF_SPARC_HWCAP_DIV32)
13220         printf ("%sdiv32", first ? "" : "|"), first = 0;
13221       if (mask & ELF_SPARC_HWCAP_FSMULD)
13222         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13223       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13224         printf ("%sv8plus", first ? "" : "|"), first = 0;
13225       if (mask & ELF_SPARC_HWCAP_POPC)
13226         printf ("%spopc", first ? "" : "|"), first = 0;
13227       if (mask & ELF_SPARC_HWCAP_VIS)
13228         printf ("%svis", first ? "" : "|"), first = 0;
13229       if (mask & ELF_SPARC_HWCAP_VIS2)
13230         printf ("%svis2", first ? "" : "|"), first = 0;
13231       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13232         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13233       if (mask & ELF_SPARC_HWCAP_FMAF)
13234         printf ("%sfmaf", first ? "" : "|"), first = 0;
13235       if (mask & ELF_SPARC_HWCAP_VIS3)
13236         printf ("%svis3", first ? "" : "|"), first = 0;
13237       if (mask & ELF_SPARC_HWCAP_HPC)
13238         printf ("%shpc", first ? "" : "|"), first = 0;
13239       if (mask & ELF_SPARC_HWCAP_RANDOM)
13240         printf ("%srandom", first ? "" : "|"), first = 0;
13241       if (mask & ELF_SPARC_HWCAP_TRANS)
13242         printf ("%strans", first ? "" : "|"), first = 0;
13243       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13244         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13245       if (mask & ELF_SPARC_HWCAP_IMA)
13246         printf ("%sima", first ? "" : "|"), first = 0;
13247       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13248         printf ("%scspare", first ? "" : "|"), first = 0;
13249     }
13250   else
13251     fputc ('0', stdout);
13252   fputc ('\n', stdout);
13253 }
13254
13255 static void
13256 display_sparc_hwcaps2 (int mask)
13257 {
13258   if (mask)
13259     {
13260       int first = 1;
13261
13262       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13263         fputs ("fjathplus", stdout), first = 0;
13264       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13265         printf ("%svis3b", first ? "" : "|"), first = 0;
13266       if (mask & ELF_SPARC_HWCAP2_ADP)
13267         printf ("%sadp", first ? "" : "|"), first = 0;
13268       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13269         printf ("%ssparc5", first ? "" : "|"), first = 0;
13270       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13271         printf ("%smwait", first ? "" : "|"), first = 0;
13272       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13273         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13274       if (mask & ELF_SPARC_HWCAP2_XMONT)
13275         printf ("%sxmont2", first ? "" : "|"), first = 0;
13276       if (mask & ELF_SPARC_HWCAP2_NSEC)
13277         printf ("%snsec", first ? "" : "|"), first = 0;
13278       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13279         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13280       if (mask & ELF_SPARC_HWCAP2_FJDES)
13281         printf ("%sfjdes", first ? "" : "|"), first = 0;
13282       if (mask & ELF_SPARC_HWCAP2_FJAES)
13283         printf ("%sfjaes", first ? "" : "|"), first = 0;
13284     }
13285   else
13286     fputc ('0', stdout);
13287   fputc ('\n', stdout);
13288 }
13289
13290 static unsigned char *
13291 display_sparc_gnu_attribute (unsigned char * p,
13292                              int tag,
13293                              const unsigned char * const end)
13294 {
13295   unsigned int len;
13296   int val;
13297
13298   if (tag == Tag_GNU_Sparc_HWCAPS)
13299     {
13300       val = read_uleb128 (p, &len, end);
13301       p += len;
13302       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13303       display_sparc_hwcaps (val);
13304       return p;
13305     }
13306   if (tag == Tag_GNU_Sparc_HWCAPS2)
13307     {
13308       val = read_uleb128 (p, &len, end);
13309       p += len;
13310       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13311       display_sparc_hwcaps2 (val);
13312       return p;
13313     }
13314
13315   return display_tag_value (tag, p, end);
13316 }
13317
13318 static void
13319 print_mips_fp_abi_value (int val)
13320 {
13321   switch (val)
13322     {
13323     case Val_GNU_MIPS_ABI_FP_ANY:
13324       printf (_("Hard or soft float\n"));
13325       break;
13326     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13327       printf (_("Hard float (double precision)\n"));
13328       break;
13329     case Val_GNU_MIPS_ABI_FP_SINGLE:
13330       printf (_("Hard float (single precision)\n"));
13331       break;
13332     case Val_GNU_MIPS_ABI_FP_SOFT:
13333       printf (_("Soft float\n"));
13334       break;
13335     case Val_GNU_MIPS_ABI_FP_OLD_64:
13336       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13337       break;
13338     case Val_GNU_MIPS_ABI_FP_XX:
13339       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13340       break;
13341     case Val_GNU_MIPS_ABI_FP_64:
13342       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13343       break;
13344     case Val_GNU_MIPS_ABI_FP_64A:
13345       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13346       break;
13347     case Val_GNU_MIPS_ABI_FP_NAN2008:
13348       printf (_("NaN 2008 compatibility\n"));
13349       break;
13350     default:
13351       printf ("??? (%d)\n", val);
13352       break;
13353     }
13354 }
13355
13356 static unsigned char *
13357 display_mips_gnu_attribute (unsigned char * p,
13358                             int tag,
13359                             const unsigned char * const end)
13360 {
13361   if (tag == Tag_GNU_MIPS_ABI_FP)
13362     {
13363       unsigned int len;
13364       int val;
13365
13366       val = read_uleb128 (p, &len, end);
13367       p += len;
13368       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13369
13370       print_mips_fp_abi_value (val);
13371
13372       return p;
13373    }
13374
13375   if (tag == Tag_GNU_MIPS_ABI_MSA)
13376     {
13377       unsigned int len;
13378       int val;
13379
13380       val = read_uleb128 (p, &len, end);
13381       p += len;
13382       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13383
13384       switch (val)
13385         {
13386         case Val_GNU_MIPS_ABI_MSA_ANY:
13387           printf (_("Any MSA or not\n"));
13388           break;
13389         case Val_GNU_MIPS_ABI_MSA_128:
13390           printf (_("128-bit MSA\n"));
13391           break;
13392         default:
13393           printf ("??? (%d)\n", val);
13394           break;
13395         }
13396       return p;
13397     }
13398
13399   return display_tag_value (tag & 1, p, end);
13400 }
13401
13402 static unsigned char *
13403 display_tic6x_attribute (unsigned char * p,
13404                          const unsigned char * const end)
13405 {
13406   int tag;
13407   unsigned int len;
13408   int val;
13409
13410   tag = read_uleb128 (p, &len, end);
13411   p += len;
13412
13413   switch (tag)
13414     {
13415     case Tag_ISA:
13416       val = read_uleb128 (p, &len, end);
13417       p += len;
13418       printf ("  Tag_ISA: ");
13419
13420       switch (val)
13421         {
13422         case C6XABI_Tag_ISA_none:
13423           printf (_("None\n"));
13424           break;
13425         case C6XABI_Tag_ISA_C62X:
13426           printf ("C62x\n");
13427           break;
13428         case C6XABI_Tag_ISA_C67X:
13429           printf ("C67x\n");
13430           break;
13431         case C6XABI_Tag_ISA_C67XP:
13432           printf ("C67x+\n");
13433           break;
13434         case C6XABI_Tag_ISA_C64X:
13435           printf ("C64x\n");
13436           break;
13437         case C6XABI_Tag_ISA_C64XP:
13438           printf ("C64x+\n");
13439           break;
13440         case C6XABI_Tag_ISA_C674X:
13441           printf ("C674x\n");
13442           break;
13443         default:
13444           printf ("??? (%d)\n", val);
13445           break;
13446         }
13447       return p;
13448
13449     case Tag_ABI_wchar_t:
13450       val = read_uleb128 (p, &len, end);
13451       p += len;
13452       printf ("  Tag_ABI_wchar_t: ");
13453       switch (val)
13454         {
13455         case 0:
13456           printf (_("Not used\n"));
13457           break;
13458         case 1:
13459           printf (_("2 bytes\n"));
13460           break;
13461         case 2:
13462           printf (_("4 bytes\n"));
13463           break;
13464         default:
13465           printf ("??? (%d)\n", val);
13466           break;
13467         }
13468       return p;
13469
13470     case Tag_ABI_stack_align_needed:
13471       val = read_uleb128 (p, &len, end);
13472       p += len;
13473       printf ("  Tag_ABI_stack_align_needed: ");
13474       switch (val)
13475         {
13476         case 0:
13477           printf (_("8-byte\n"));
13478           break;
13479         case 1:
13480           printf (_("16-byte\n"));
13481           break;
13482         default:
13483           printf ("??? (%d)\n", val);
13484           break;
13485         }
13486       return p;
13487
13488     case Tag_ABI_stack_align_preserved:
13489       val = read_uleb128 (p, &len, end);
13490       p += len;
13491       printf ("  Tag_ABI_stack_align_preserved: ");
13492       switch (val)
13493         {
13494         case 0:
13495           printf (_("8-byte\n"));
13496           break;
13497         case 1:
13498           printf (_("16-byte\n"));
13499           break;
13500         default:
13501           printf ("??? (%d)\n", val);
13502           break;
13503         }
13504       return p;
13505
13506     case Tag_ABI_DSBT:
13507       val = read_uleb128 (p, &len, end);
13508       p += len;
13509       printf ("  Tag_ABI_DSBT: ");
13510       switch (val)
13511         {
13512         case 0:
13513           printf (_("DSBT addressing not used\n"));
13514           break;
13515         case 1:
13516           printf (_("DSBT addressing used\n"));
13517           break;
13518         default:
13519           printf ("??? (%d)\n", val);
13520           break;
13521         }
13522       return p;
13523
13524     case Tag_ABI_PID:
13525       val = read_uleb128 (p, &len, end);
13526       p += len;
13527       printf ("  Tag_ABI_PID: ");
13528       switch (val)
13529         {
13530         case 0:
13531           printf (_("Data addressing position-dependent\n"));
13532           break;
13533         case 1:
13534           printf (_("Data addressing position-independent, GOT near DP\n"));
13535           break;
13536         case 2:
13537           printf (_("Data addressing position-independent, GOT far from DP\n"));
13538           break;
13539         default:
13540           printf ("??? (%d)\n", val);
13541           break;
13542         }
13543       return p;
13544
13545     case Tag_ABI_PIC:
13546       val = read_uleb128 (p, &len, end);
13547       p += len;
13548       printf ("  Tag_ABI_PIC: ");
13549       switch (val)
13550         {
13551         case 0:
13552           printf (_("Code addressing position-dependent\n"));
13553           break;
13554         case 1:
13555           printf (_("Code addressing position-independent\n"));
13556           break;
13557         default:
13558           printf ("??? (%d)\n", val);
13559           break;
13560         }
13561       return p;
13562
13563     case Tag_ABI_array_object_alignment:
13564       val = read_uleb128 (p, &len, end);
13565       p += len;
13566       printf ("  Tag_ABI_array_object_alignment: ");
13567       switch (val)
13568         {
13569         case 0:
13570           printf (_("8-byte\n"));
13571           break;
13572         case 1:
13573           printf (_("4-byte\n"));
13574           break;
13575         case 2:
13576           printf (_("16-byte\n"));
13577           break;
13578         default:
13579           printf ("??? (%d)\n", val);
13580           break;
13581         }
13582       return p;
13583
13584     case Tag_ABI_array_object_align_expected:
13585       val = read_uleb128 (p, &len, end);
13586       p += len;
13587       printf ("  Tag_ABI_array_object_align_expected: ");
13588       switch (val)
13589         {
13590         case 0:
13591           printf (_("8-byte\n"));
13592           break;
13593         case 1:
13594           printf (_("4-byte\n"));
13595           break;
13596         case 2:
13597           printf (_("16-byte\n"));
13598           break;
13599         default:
13600           printf ("??? (%d)\n", val);
13601           break;
13602         }
13603       return p;
13604
13605     case Tag_ABI_compatibility:
13606       {
13607         val = read_uleb128 (p, &len, end);
13608         p += len;
13609         printf ("  Tag_ABI_compatibility: ");
13610         printf (_("flag = %d, vendor = "), val);
13611         if (p < end - 1)
13612           {
13613             size_t maxlen = (end - p) - 1;
13614
13615             print_symbol ((int) maxlen, (const char *) p);
13616             p += strnlen ((char *) p, maxlen) + 1;
13617           }
13618         else
13619           {
13620             printf (_("<corrupt>"));
13621             p = (unsigned char *) end;
13622           }
13623         putchar ('\n');
13624         return p;
13625       }
13626
13627     case Tag_ABI_conformance:
13628       {
13629         printf ("  Tag_ABI_conformance: \"");
13630         if (p < end - 1)
13631           {
13632             size_t maxlen = (end - p) - 1;
13633
13634             print_symbol ((int) maxlen, (const char *) p);
13635             p += strnlen ((char *) p, maxlen) + 1;
13636           }
13637         else
13638           {
13639             printf (_("<corrupt>"));
13640             p = (unsigned char *) end;
13641           }
13642         printf ("\"\n");
13643         return p;
13644       }
13645     }
13646
13647   return display_tag_value (tag, p, end);
13648 }
13649
13650 static void
13651 display_raw_attribute (unsigned char * p, unsigned char * end)
13652 {
13653   unsigned long addr = 0;
13654   size_t bytes = end - p;
13655
13656   assert (end > p);
13657   while (bytes)
13658     {
13659       int j;
13660       int k;
13661       int lbytes = (bytes > 16 ? 16 : bytes);
13662
13663       printf ("  0x%8.8lx ", addr);
13664
13665       for (j = 0; j < 16; j++)
13666         {
13667           if (j < lbytes)
13668             printf ("%2.2x", p[j]);
13669           else
13670             printf ("  ");
13671
13672           if ((j & 3) == 3)
13673             printf (" ");
13674         }
13675
13676       for (j = 0; j < lbytes; j++)
13677         {
13678           k = p[j];
13679           if (k >= ' ' && k < 0x7f)
13680             printf ("%c", k);
13681           else
13682             printf (".");
13683         }
13684
13685       putchar ('\n');
13686
13687       p  += lbytes;
13688       bytes -= lbytes;
13689       addr += lbytes;
13690     }
13691
13692   putchar ('\n');
13693 }
13694
13695 static unsigned char *
13696 display_msp430x_attribute (unsigned char * p,
13697                            const unsigned char * const end)
13698 {
13699   unsigned int len;
13700   int val;
13701   int tag;
13702
13703   tag = read_uleb128 (p, & len, end);
13704   p += len;
13705
13706   switch (tag)
13707     {
13708     case OFBA_MSPABI_Tag_ISA:
13709       val = read_uleb128 (p, &len, end);
13710       p += len;
13711       printf ("  Tag_ISA: ");
13712       switch (val)
13713         {
13714         case 0: printf (_("None\n")); break;
13715         case 1: printf (_("MSP430\n")); break;
13716         case 2: printf (_("MSP430X\n")); break;
13717         default: printf ("??? (%d)\n", val); break;
13718         }
13719       break;
13720
13721     case OFBA_MSPABI_Tag_Code_Model:
13722       val = read_uleb128 (p, &len, end);
13723       p += len;
13724       printf ("  Tag_Code_Model: ");
13725       switch (val)
13726         {
13727         case 0: printf (_("None\n")); break;
13728         case 1: printf (_("Small\n")); break;
13729         case 2: printf (_("Large\n")); break;
13730         default: printf ("??? (%d)\n", val); break;
13731         }
13732       break;
13733
13734     case OFBA_MSPABI_Tag_Data_Model:
13735       val = read_uleb128 (p, &len, end);
13736       p += len;
13737       printf ("  Tag_Data_Model: ");
13738       switch (val)
13739         {
13740         case 0: printf (_("None\n")); break;
13741         case 1: printf (_("Small\n")); break;
13742         case 2: printf (_("Large\n")); break;
13743         case 3: printf (_("Restricted Large\n")); break;
13744         default: printf ("??? (%d)\n", val); break;
13745         }
13746       break;
13747
13748     default:
13749       printf (_("  <unknown tag %d>: "), tag);
13750
13751       if (tag & 1)
13752         {
13753           putchar ('"');
13754           if (p < end - 1)
13755             {
13756               size_t maxlen = (end - p) - 1;
13757
13758               print_symbol ((int) maxlen, (const char *) p);
13759               p += strnlen ((char *) p, maxlen) + 1;
13760             }
13761           else
13762             {
13763               printf (_("<corrupt>"));
13764               p = (unsigned char *) end;
13765             }
13766           printf ("\"\n");
13767         }
13768       else
13769         {
13770           val = read_uleb128 (p, &len, end);
13771           p += len;
13772           printf ("%d (0x%x)\n", val, val);
13773         }
13774       break;
13775    }
13776
13777   assert (p <= end);
13778   return p;
13779 }
13780
13781 static int
13782 process_attributes (FILE * file,
13783                     const char * public_name,
13784                     unsigned int proc_type,
13785                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13786                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13787 {
13788   Elf_Internal_Shdr * sect;
13789   unsigned i;
13790
13791   /* Find the section header so that we get the size.  */
13792   for (i = 0, sect = section_headers;
13793        i < elf_header.e_shnum;
13794        i++, sect++)
13795     {
13796       unsigned char * contents;
13797       unsigned char * p;
13798
13799       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13800         continue;
13801
13802       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13803                                              sect->sh_size, _("attributes"));
13804       if (contents == NULL)
13805         continue;
13806
13807       p = contents;
13808       if (*p == 'A')
13809         {
13810           bfd_vma section_len;
13811
13812           section_len = sect->sh_size - 1;
13813           p++;
13814
13815           while (section_len > 0)
13816             {
13817               bfd_vma attr_len;
13818               unsigned int namelen;
13819               bfd_boolean public_section;
13820               bfd_boolean gnu_section;
13821
13822               if (section_len <= 4)
13823                 {
13824                   error (_("Tag section ends prematurely\n"));
13825                   break;
13826                 }
13827               attr_len = byte_get (p, 4);
13828               p += 4;
13829
13830               if (attr_len > section_len)
13831                 {
13832                   error (_("Bad attribute length (%u > %u)\n"),
13833                           (unsigned) attr_len, (unsigned) section_len);
13834                   attr_len = section_len;
13835                 }
13836               /* PR 17531: file: 001-101425-0.004  */
13837               else if (attr_len < 5)
13838                 {
13839                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13840                   break;
13841                 }
13842
13843               section_len -= attr_len;
13844               attr_len -= 4;
13845
13846               namelen = strnlen ((char *) p, attr_len) + 1;
13847               if (namelen == 0 || namelen >= attr_len)
13848                 {
13849                   error (_("Corrupt attribute section name\n"));
13850                   break;
13851                 }
13852
13853               printf (_("Attribute Section: "));
13854               print_symbol (INT_MAX, (const char *) p);
13855               putchar ('\n');
13856
13857               if (public_name && streq ((char *) p, public_name))
13858                 public_section = TRUE;
13859               else
13860                 public_section = FALSE;
13861
13862               if (streq ((char *) p, "gnu"))
13863                 gnu_section = TRUE;
13864               else
13865                 gnu_section = FALSE;
13866
13867               p += namelen;
13868               attr_len -= namelen;
13869
13870               while (attr_len > 0 && p < contents + sect->sh_size)
13871                 {
13872                   int tag;
13873                   int val;
13874                   bfd_vma size;
13875                   unsigned char * end;
13876
13877                   /* PR binutils/17531: Safe handling of corrupt files.  */
13878                   if (attr_len < 6)
13879                     {
13880                       error (_("Unused bytes at end of section\n"));
13881                       section_len = 0;
13882                       break;
13883                     }
13884
13885                   tag = *(p++);
13886                   size = byte_get (p, 4);
13887                   if (size > attr_len)
13888                     {
13889                       error (_("Bad subsection length (%u > %u)\n"),
13890                               (unsigned) size, (unsigned) attr_len);
13891                       size = attr_len;
13892                     }
13893                   /* PR binutils/17531: Safe handling of corrupt files.  */
13894                   if (size < 6)
13895                     {
13896                       error (_("Bad subsection length (%u < 6)\n"),
13897                               (unsigned) size);
13898                       section_len = 0;
13899                       break;
13900                     }
13901
13902                   attr_len -= size;
13903                   end = p + size - 1;
13904                   assert (end <= contents + sect->sh_size);
13905                   p += 4;
13906
13907                   switch (tag)
13908                     {
13909                     case 1:
13910                       printf (_("File Attributes\n"));
13911                       break;
13912                     case 2:
13913                       printf (_("Section Attributes:"));
13914                       goto do_numlist;
13915                     case 3:
13916                       printf (_("Symbol Attributes:"));
13917                     do_numlist:
13918                       for (;;)
13919                         {
13920                           unsigned int j;
13921
13922                           val = read_uleb128 (p, &j, end);
13923                           p += j;
13924                           if (val == 0)
13925                             break;
13926                           printf (" %d", val);
13927                         }
13928                       printf ("\n");
13929                       break;
13930                     default:
13931                       printf (_("Unknown tag: %d\n"), tag);
13932                       public_section = FALSE;
13933                       break;
13934                     }
13935
13936                   if (public_section && display_pub_attribute != NULL)
13937                     {
13938                       while (p < end)
13939                         p = display_pub_attribute (p, end);
13940                       assert (p <= end);
13941                     }
13942                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13943                     {
13944                       while (p < end)
13945                         p = display_gnu_attribute (p,
13946                                                    display_proc_gnu_attribute,
13947                                                    end);
13948                       assert (p <= end);
13949                     }
13950                   else if (p < end)
13951                     {
13952                       printf (_("  Unknown attribute:\n"));
13953                       display_raw_attribute (p, end);
13954                       p = end;
13955                     }
13956                   else
13957                     attr_len = 0;
13958                 }
13959             }
13960         }
13961       else
13962         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13963
13964       free (contents);
13965     }
13966   return 1;
13967 }
13968
13969 static int
13970 process_arm_specific (FILE * file)
13971 {
13972   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13973                              display_arm_attribute, NULL);
13974 }
13975
13976 static int
13977 process_power_specific (FILE * file)
13978 {
13979   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13980                              display_power_gnu_attribute);
13981 }
13982
13983 static int
13984 process_s390_specific (FILE * file)
13985 {
13986   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13987                              display_s390_gnu_attribute);
13988 }
13989
13990 static int
13991 process_sparc_specific (FILE * file)
13992 {
13993   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13994                              display_sparc_gnu_attribute);
13995 }
13996
13997 static int
13998 process_tic6x_specific (FILE * file)
13999 {
14000   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14001                              display_tic6x_attribute, NULL);
14002 }
14003
14004 static int
14005 process_msp430x_specific (FILE * file)
14006 {
14007   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14008                              display_msp430x_attribute, NULL);
14009 }
14010
14011 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14012    Print the Address, Access and Initial fields of an entry at VMA ADDR
14013    and return the VMA of the next entry, or -1 if there was a problem.
14014    Does not read from DATA_END or beyond.  */
14015
14016 static bfd_vma
14017 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14018                       unsigned char * data_end)
14019 {
14020   printf ("  ");
14021   print_vma (addr, LONG_HEX);
14022   printf (" ");
14023   if (addr < pltgot + 0xfff0)
14024     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14025   else
14026     printf ("%10s", "");
14027   printf (" ");
14028   if (data == NULL)
14029     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14030   else
14031     {
14032       bfd_vma entry;
14033       unsigned char * from = data + addr - pltgot;
14034
14035       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14036         {
14037           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14038           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14039           return (bfd_vma) -1;
14040         }
14041       else
14042         {
14043           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14044           print_vma (entry, LONG_HEX);
14045         }
14046     }
14047   return addr + (is_32bit_elf ? 4 : 8);
14048 }
14049
14050 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14051    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14052    ADDR and return the VMA of the next entry.  */
14053
14054 static bfd_vma
14055 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14056 {
14057   printf ("  ");
14058   print_vma (addr, LONG_HEX);
14059   printf (" ");
14060   if (data == NULL)
14061     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14062   else
14063     {
14064       bfd_vma entry;
14065
14066       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14067       print_vma (entry, LONG_HEX);
14068     }
14069   return addr + (is_32bit_elf ? 4 : 8);
14070 }
14071
14072 static void
14073 print_mips_ases (unsigned int mask)
14074 {
14075   if (mask & AFL_ASE_DSP)
14076     fputs ("\n\tDSP ASE", stdout);
14077   if (mask & AFL_ASE_DSPR2)
14078     fputs ("\n\tDSP R2 ASE", stdout);
14079   if (mask & AFL_ASE_EVA)
14080     fputs ("\n\tEnhanced VA Scheme", stdout);
14081   if (mask & AFL_ASE_MCU)
14082     fputs ("\n\tMCU (MicroController) ASE", stdout);
14083   if (mask & AFL_ASE_MDMX)
14084     fputs ("\n\tMDMX ASE", stdout);
14085   if (mask & AFL_ASE_MIPS3D)
14086     fputs ("\n\tMIPS-3D ASE", stdout);
14087   if (mask & AFL_ASE_MT)
14088     fputs ("\n\tMT ASE", stdout);
14089   if (mask & AFL_ASE_SMARTMIPS)
14090     fputs ("\n\tSmartMIPS ASE", stdout);
14091   if (mask & AFL_ASE_VIRT)
14092     fputs ("\n\tVZ ASE", stdout);
14093   if (mask & AFL_ASE_MSA)
14094     fputs ("\n\tMSA ASE", stdout);
14095   if (mask & AFL_ASE_MIPS16)
14096     fputs ("\n\tMIPS16 ASE", stdout);
14097   if (mask & AFL_ASE_MICROMIPS)
14098     fputs ("\n\tMICROMIPS ASE", stdout);
14099   if (mask & AFL_ASE_XPA)
14100     fputs ("\n\tXPA ASE", stdout);
14101   if (mask == 0)
14102     fprintf (stdout, "\n\t%s", _("None"));
14103   else if ((mask & ~AFL_ASE_MASK) != 0)
14104     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14105 }
14106
14107 static void
14108 print_mips_isa_ext (unsigned int isa_ext)
14109 {
14110   switch (isa_ext)
14111     {
14112     case 0:
14113       fputs (_("None"), stdout);
14114       break;
14115     case AFL_EXT_XLR:
14116       fputs ("RMI XLR", stdout);
14117       break;
14118     case AFL_EXT_OCTEON3:
14119       fputs ("Cavium Networks Octeon3", stdout);
14120       break;
14121     case AFL_EXT_OCTEON2:
14122       fputs ("Cavium Networks Octeon2", stdout);
14123       break;
14124     case AFL_EXT_OCTEONP:
14125       fputs ("Cavium Networks OcteonP", stdout);
14126       break;
14127     case AFL_EXT_LOONGSON_3A:
14128       fputs ("Loongson 3A", stdout);
14129       break;
14130     case AFL_EXT_OCTEON:
14131       fputs ("Cavium Networks Octeon", stdout);
14132       break;
14133     case AFL_EXT_5900:
14134       fputs ("Toshiba R5900", stdout);
14135       break;
14136     case AFL_EXT_4650:
14137       fputs ("MIPS R4650", stdout);
14138       break;
14139     case AFL_EXT_4010:
14140       fputs ("LSI R4010", stdout);
14141       break;
14142     case AFL_EXT_4100:
14143       fputs ("NEC VR4100", stdout);
14144       break;
14145     case AFL_EXT_3900:
14146       fputs ("Toshiba R3900", stdout);
14147       break;
14148     case AFL_EXT_10000:
14149       fputs ("MIPS R10000", stdout);
14150       break;
14151     case AFL_EXT_SB1:
14152       fputs ("Broadcom SB-1", stdout);
14153       break;
14154     case AFL_EXT_4111:
14155       fputs ("NEC VR4111/VR4181", stdout);
14156       break;
14157     case AFL_EXT_4120:
14158       fputs ("NEC VR4120", stdout);
14159       break;
14160     case AFL_EXT_5400:
14161       fputs ("NEC VR5400", stdout);
14162       break;
14163     case AFL_EXT_5500:
14164       fputs ("NEC VR5500", stdout);
14165       break;
14166     case AFL_EXT_LOONGSON_2E:
14167       fputs ("ST Microelectronics Loongson 2E", stdout);
14168       break;
14169     case AFL_EXT_LOONGSON_2F:
14170       fputs ("ST Microelectronics Loongson 2F", stdout);
14171       break;
14172     default:
14173       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14174     }
14175 }
14176
14177 static int
14178 get_mips_reg_size (int reg_size)
14179 {
14180   return (reg_size == AFL_REG_NONE) ? 0
14181          : (reg_size == AFL_REG_32) ? 32
14182          : (reg_size == AFL_REG_64) ? 64
14183          : (reg_size == AFL_REG_128) ? 128
14184          : -1;
14185 }
14186
14187 static int
14188 process_mips_specific (FILE * file)
14189 {
14190   Elf_Internal_Dyn * entry;
14191   Elf_Internal_Shdr *sect = NULL;
14192   size_t liblist_offset = 0;
14193   size_t liblistno = 0;
14194   size_t conflictsno = 0;
14195   size_t options_offset = 0;
14196   size_t conflicts_offset = 0;
14197   size_t pltrelsz = 0;
14198   size_t pltrel = 0;
14199   bfd_vma pltgot = 0;
14200   bfd_vma mips_pltgot = 0;
14201   bfd_vma jmprel = 0;
14202   bfd_vma local_gotno = 0;
14203   bfd_vma gotsym = 0;
14204   bfd_vma symtabno = 0;
14205
14206   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14207                       display_mips_gnu_attribute);
14208
14209   sect = find_section (".MIPS.abiflags");
14210
14211   if (sect != NULL)
14212     {
14213       Elf_External_ABIFlags_v0 *abiflags_ext;
14214       Elf_Internal_ABIFlags_v0 abiflags_in;
14215
14216       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14217         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14218       else
14219         {
14220           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14221                                    sect->sh_size, _("MIPS ABI Flags section"));
14222           if (abiflags_ext)
14223             {
14224               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14225               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14226               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14227               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14228               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14229               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14230               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14231               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14232               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14233               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14234               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14235
14236               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14237               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14238               if (abiflags_in.isa_rev > 1)
14239                 printf ("r%d", abiflags_in.isa_rev);
14240               printf ("\nGPR size: %d",
14241                       get_mips_reg_size (abiflags_in.gpr_size));
14242               printf ("\nCPR1 size: %d",
14243                       get_mips_reg_size (abiflags_in.cpr1_size));
14244               printf ("\nCPR2 size: %d",
14245                       get_mips_reg_size (abiflags_in.cpr2_size));
14246               fputs ("\nFP ABI: ", stdout);
14247               print_mips_fp_abi_value (abiflags_in.fp_abi);
14248               fputs ("ISA Extension: ", stdout);
14249               print_mips_isa_ext (abiflags_in.isa_ext);
14250               fputs ("\nASEs:", stdout);
14251               print_mips_ases (abiflags_in.ases);
14252               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14253               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14254               fputc ('\n', stdout);
14255               free (abiflags_ext);
14256             }
14257         }
14258     }
14259
14260   /* We have a lot of special sections.  Thanks SGI!  */
14261   if (dynamic_section == NULL)
14262     /* No information available.  */
14263     return 0;
14264
14265   for (entry = dynamic_section;
14266        /* PR 17531 file: 012-50589-0.004.  */
14267        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14268        ++entry)
14269     switch (entry->d_tag)
14270       {
14271       case DT_MIPS_LIBLIST:
14272         liblist_offset
14273           = offset_from_vma (file, entry->d_un.d_val,
14274                              liblistno * sizeof (Elf32_External_Lib));
14275         break;
14276       case DT_MIPS_LIBLISTNO:
14277         liblistno = entry->d_un.d_val;
14278         break;
14279       case DT_MIPS_OPTIONS:
14280         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14281         break;
14282       case DT_MIPS_CONFLICT:
14283         conflicts_offset
14284           = offset_from_vma (file, entry->d_un.d_val,
14285                              conflictsno * sizeof (Elf32_External_Conflict));
14286         break;
14287       case DT_MIPS_CONFLICTNO:
14288         conflictsno = entry->d_un.d_val;
14289         break;
14290       case DT_PLTGOT:
14291         pltgot = entry->d_un.d_ptr;
14292         break;
14293       case DT_MIPS_LOCAL_GOTNO:
14294         local_gotno = entry->d_un.d_val;
14295         break;
14296       case DT_MIPS_GOTSYM:
14297         gotsym = entry->d_un.d_val;
14298         break;
14299       case DT_MIPS_SYMTABNO:
14300         symtabno = entry->d_un.d_val;
14301         break;
14302       case DT_MIPS_PLTGOT:
14303         mips_pltgot = entry->d_un.d_ptr;
14304         break;
14305       case DT_PLTREL:
14306         pltrel = entry->d_un.d_val;
14307         break;
14308       case DT_PLTRELSZ:
14309         pltrelsz = entry->d_un.d_val;
14310         break;
14311       case DT_JMPREL:
14312         jmprel = entry->d_un.d_ptr;
14313         break;
14314       default:
14315         break;
14316       }
14317
14318   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14319     {
14320       Elf32_External_Lib * elib;
14321       size_t cnt;
14322
14323       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14324                                               liblistno,
14325                                               sizeof (Elf32_External_Lib),
14326                                               _("liblist section data"));
14327       if (elib)
14328         {
14329           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14330                   (unsigned long) liblistno);
14331           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14332                  stdout);
14333
14334           for (cnt = 0; cnt < liblistno; ++cnt)
14335             {
14336               Elf32_Lib liblist;
14337               time_t atime;
14338               char timebuf[20];
14339               struct tm * tmp;
14340
14341               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14342               atime = BYTE_GET (elib[cnt].l_time_stamp);
14343               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14344               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14345               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14346
14347               tmp = gmtime (&atime);
14348               snprintf (timebuf, sizeof (timebuf),
14349                         "%04u-%02u-%02uT%02u:%02u:%02u",
14350                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14351                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14352
14353               printf ("%3lu: ", (unsigned long) cnt);
14354               if (VALID_DYNAMIC_NAME (liblist.l_name))
14355                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14356               else
14357                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14358               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14359                       liblist.l_version);
14360
14361               if (liblist.l_flags == 0)
14362                 puts (_(" NONE"));
14363               else
14364                 {
14365                   static const struct
14366                   {
14367                     const char * name;
14368                     int bit;
14369                   }
14370                   l_flags_vals[] =
14371                   {
14372                     { " EXACT_MATCH", LL_EXACT_MATCH },
14373                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14374                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14375                     { " EXPORTS", LL_EXPORTS },
14376                     { " DELAY_LOAD", LL_DELAY_LOAD },
14377                     { " DELTA", LL_DELTA }
14378                   };
14379                   int flags = liblist.l_flags;
14380                   size_t fcnt;
14381
14382                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14383                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14384                       {
14385                         fputs (l_flags_vals[fcnt].name, stdout);
14386                         flags ^= l_flags_vals[fcnt].bit;
14387                       }
14388                   if (flags != 0)
14389                     printf (" %#x", (unsigned int) flags);
14390
14391                   puts ("");
14392                 }
14393             }
14394
14395           free (elib);
14396         }
14397     }
14398
14399   if (options_offset != 0)
14400     {
14401       Elf_External_Options * eopt;
14402       Elf_Internal_Options * iopt;
14403       Elf_Internal_Options * option;
14404       size_t offset;
14405       int cnt;
14406       sect = section_headers;
14407
14408       /* Find the section header so that we get the size.  */
14409       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14410       /* PR 17533 file: 012-277276-0.004.  */
14411       if (sect == NULL)
14412         {
14413           error (_("No MIPS_OPTIONS header found\n"));
14414           return 0;
14415         }
14416
14417       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14418                                                 sect->sh_size, _("options"));
14419       if (eopt)
14420         {
14421           iopt = (Elf_Internal_Options *)
14422               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14423           if (iopt == NULL)
14424             {
14425               error (_("Out of memory allocatinf space for MIPS options\n"));
14426               return 0;
14427             }
14428
14429           offset = cnt = 0;
14430           option = iopt;
14431
14432           while (offset <= sect->sh_size - sizeof (* eopt))
14433             {
14434               Elf_External_Options * eoption;
14435
14436               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14437
14438               option->kind = BYTE_GET (eoption->kind);
14439               option->size = BYTE_GET (eoption->size);
14440               option->section = BYTE_GET (eoption->section);
14441               option->info = BYTE_GET (eoption->info);
14442
14443               /* PR 17531: file: ffa0fa3b.  */
14444               if (option->size < sizeof (* eopt)
14445                   || offset + option->size > sect->sh_size)
14446                 {
14447                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14448                   return 0;
14449                 }
14450               offset += option->size;
14451
14452               ++option;
14453               ++cnt;
14454             }
14455
14456           printf (_("\nSection '%s' contains %d entries:\n"),
14457                   printable_section_name (sect), cnt);
14458
14459           option = iopt;
14460           offset = 0;
14461
14462           while (cnt-- > 0)
14463             {
14464               size_t len;
14465
14466               switch (option->kind)
14467                 {
14468                 case ODK_NULL:
14469                   /* This shouldn't happen.  */
14470                   printf (" NULL       %d %lx", option->section, option->info);
14471                   break;
14472                 case ODK_REGINFO:
14473                   printf (" REGINFO    ");
14474                   if (elf_header.e_machine == EM_MIPS)
14475                     {
14476                       /* 32bit form.  */
14477                       Elf32_External_RegInfo * ereg;
14478                       Elf32_RegInfo reginfo;
14479
14480                       ereg = (Elf32_External_RegInfo *) (option + 1);
14481                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14482                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14483                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14484                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14485                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14486                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14487
14488                       printf ("GPR %08lx  GP 0x%lx\n",
14489                               reginfo.ri_gprmask,
14490                               (unsigned long) reginfo.ri_gp_value);
14491                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14492                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14493                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14494                     }
14495                   else
14496                     {
14497                       /* 64 bit form.  */
14498                       Elf64_External_RegInfo * ereg;
14499                       Elf64_Internal_RegInfo reginfo;
14500
14501                       ereg = (Elf64_External_RegInfo *) (option + 1);
14502                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14503                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14504                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14505                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14506                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14507                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14508
14509                       printf ("GPR %08lx  GP 0x",
14510                               reginfo.ri_gprmask);
14511                       printf_vma (reginfo.ri_gp_value);
14512                       printf ("\n");
14513
14514                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14515                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14516                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14517                     }
14518                   ++option;
14519                   continue;
14520                 case ODK_EXCEPTIONS:
14521                   fputs (" EXCEPTIONS fpe_min(", stdout);
14522                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14523                   fputs (") fpe_max(", stdout);
14524                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14525                   fputs (")", stdout);
14526
14527                   if (option->info & OEX_PAGE0)
14528                     fputs (" PAGE0", stdout);
14529                   if (option->info & OEX_SMM)
14530                     fputs (" SMM", stdout);
14531                   if (option->info & OEX_FPDBUG)
14532                     fputs (" FPDBUG", stdout);
14533                   if (option->info & OEX_DISMISS)
14534                     fputs (" DISMISS", stdout);
14535                   break;
14536                 case ODK_PAD:
14537                   fputs (" PAD       ", stdout);
14538                   if (option->info & OPAD_PREFIX)
14539                     fputs (" PREFIX", stdout);
14540                   if (option->info & OPAD_POSTFIX)
14541                     fputs (" POSTFIX", stdout);
14542                   if (option->info & OPAD_SYMBOL)
14543                     fputs (" SYMBOL", stdout);
14544                   break;
14545                 case ODK_HWPATCH:
14546                   fputs (" HWPATCH   ", stdout);
14547                   if (option->info & OHW_R4KEOP)
14548                     fputs (" R4KEOP", stdout);
14549                   if (option->info & OHW_R8KPFETCH)
14550                     fputs (" R8KPFETCH", stdout);
14551                   if (option->info & OHW_R5KEOP)
14552                     fputs (" R5KEOP", stdout);
14553                   if (option->info & OHW_R5KCVTL)
14554                     fputs (" R5KCVTL", stdout);
14555                   break;
14556                 case ODK_FILL:
14557                   fputs (" FILL       ", stdout);
14558                   /* XXX Print content of info word?  */
14559                   break;
14560                 case ODK_TAGS:
14561                   fputs (" TAGS       ", stdout);
14562                   /* XXX Print content of info word?  */
14563                   break;
14564                 case ODK_HWAND:
14565                   fputs (" HWAND     ", stdout);
14566                   if (option->info & OHWA0_R4KEOP_CHECKED)
14567                     fputs (" R4KEOP_CHECKED", stdout);
14568                   if (option->info & OHWA0_R4KEOP_CLEAN)
14569                     fputs (" R4KEOP_CLEAN", stdout);
14570                   break;
14571                 case ODK_HWOR:
14572                   fputs (" HWOR      ", stdout);
14573                   if (option->info & OHWA0_R4KEOP_CHECKED)
14574                     fputs (" R4KEOP_CHECKED", stdout);
14575                   if (option->info & OHWA0_R4KEOP_CLEAN)
14576                     fputs (" R4KEOP_CLEAN", stdout);
14577                   break;
14578                 case ODK_GP_GROUP:
14579                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14580                           option->info & OGP_GROUP,
14581                           (option->info & OGP_SELF) >> 16);
14582                   break;
14583                 case ODK_IDENT:
14584                   printf (" IDENT     %#06lx  self-contained %#06lx",
14585                           option->info & OGP_GROUP,
14586                           (option->info & OGP_SELF) >> 16);
14587                   break;
14588                 default:
14589                   /* This shouldn't happen.  */
14590                   printf (" %3d ???     %d %lx",
14591                           option->kind, option->section, option->info);
14592                   break;
14593                 }
14594
14595               len = sizeof (* eopt);
14596               while (len < option->size)
14597                 {
14598                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
14599
14600                   if (ISPRINT (datum))
14601                     printf ("%c", datum);
14602                   else
14603                     printf ("\\%03o", datum);
14604                   len ++;
14605                 }
14606               fputs ("\n", stdout);
14607
14608               offset += option->size;
14609               ++option;
14610             }
14611
14612           free (eopt);
14613         }
14614     }
14615
14616   if (conflicts_offset != 0 && conflictsno != 0)
14617     {
14618       Elf32_Conflict * iconf;
14619       size_t cnt;
14620
14621       if (dynamic_symbols == NULL)
14622         {
14623           error (_("conflict list found without a dynamic symbol table\n"));
14624           return 0;
14625         }
14626
14627       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14628       if (iconf == NULL)
14629         {
14630           error (_("Out of memory allocating space for dynamic conflicts\n"));
14631           return 0;
14632         }
14633
14634       if (is_32bit_elf)
14635         {
14636           Elf32_External_Conflict * econf32;
14637
14638           econf32 = (Elf32_External_Conflict *)
14639               get_data (NULL, file, conflicts_offset, conflictsno,
14640                         sizeof (* econf32), _("conflict"));
14641           if (!econf32)
14642             return 0;
14643
14644           for (cnt = 0; cnt < conflictsno; ++cnt)
14645             iconf[cnt] = BYTE_GET (econf32[cnt]);
14646
14647           free (econf32);
14648         }
14649       else
14650         {
14651           Elf64_External_Conflict * econf64;
14652
14653           econf64 = (Elf64_External_Conflict *)
14654               get_data (NULL, file, conflicts_offset, conflictsno,
14655                         sizeof (* econf64), _("conflict"));
14656           if (!econf64)
14657             return 0;
14658
14659           for (cnt = 0; cnt < conflictsno; ++cnt)
14660             iconf[cnt] = BYTE_GET (econf64[cnt]);
14661
14662           free (econf64);
14663         }
14664
14665       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14666               (unsigned long) conflictsno);
14667       puts (_("  Num:    Index       Value  Name"));
14668
14669       for (cnt = 0; cnt < conflictsno; ++cnt)
14670         {
14671           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14672
14673           if (iconf[cnt] >= num_dynamic_syms)
14674             printf (_("<corrupt symbol index>"));
14675           else
14676             {
14677               Elf_Internal_Sym * psym;
14678
14679               psym = & dynamic_symbols[iconf[cnt]];
14680               print_vma (psym->st_value, FULL_HEX);
14681               putchar (' ');
14682               if (VALID_DYNAMIC_NAME (psym->st_name))
14683                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14684               else
14685                 printf (_("<corrupt: %14ld>"), psym->st_name);
14686             }
14687           putchar ('\n');
14688         }
14689
14690       free (iconf);
14691     }
14692
14693   if (pltgot != 0 && local_gotno != 0)
14694     {
14695       bfd_vma ent, local_end, global_end;
14696       size_t i, offset;
14697       unsigned char * data;
14698       unsigned char * data_end;
14699       int addr_size;
14700
14701       ent = pltgot;
14702       addr_size = (is_32bit_elf ? 4 : 8);
14703       local_end = pltgot + local_gotno * addr_size;
14704
14705       /* PR binutils/17533 file: 012-111227-0.004  */
14706       if (symtabno < gotsym)
14707         {
14708           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14709                  (unsigned long) gotsym, (unsigned long) symtabno);
14710           return 0;
14711         }
14712
14713       global_end = local_end + (symtabno - gotsym) * addr_size;
14714       /* PR 17531: file: 54c91a34.  */
14715       if (global_end < local_end)
14716         {
14717           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14718           return 0;
14719         }
14720
14721       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14722       data = (unsigned char *) get_data (NULL, file, offset,
14723                                          global_end - pltgot, 1,
14724                                          _("Global Offset Table data"));
14725       if (data == NULL)
14726         return 0;
14727       data_end = data + (global_end - pltgot);
14728
14729       printf (_("\nPrimary GOT:\n"));
14730       printf (_(" Canonical gp value: "));
14731       print_vma (pltgot + 0x7ff0, LONG_HEX);
14732       printf ("\n\n");
14733
14734       printf (_(" Reserved entries:\n"));
14735       printf (_("  %*s %10s %*s Purpose\n"),
14736               addr_size * 2, _("Address"), _("Access"),
14737               addr_size * 2, _("Initial"));
14738       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14739       printf (_(" Lazy resolver\n"));
14740       if (ent == (bfd_vma) -1)
14741         goto got_print_fail;
14742       if (data
14743           && (byte_get (data + ent - pltgot, addr_size)
14744               >> (addr_size * 8 - 1)) != 0)
14745         {
14746           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14747           printf (_(" Module pointer (GNU extension)\n"));
14748           if (ent == (bfd_vma) -1)
14749             goto got_print_fail;
14750         }
14751       printf ("\n");
14752
14753       if (ent < local_end)
14754         {
14755           printf (_(" Local entries:\n"));
14756           printf ("  %*s %10s %*s\n",
14757                   addr_size * 2, _("Address"), _("Access"),
14758                   addr_size * 2, _("Initial"));
14759           while (ent < local_end)
14760             {
14761               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14762               printf ("\n");
14763               if (ent == (bfd_vma) -1)
14764                 goto got_print_fail;
14765             }
14766           printf ("\n");
14767         }
14768
14769       if (gotsym < symtabno)
14770         {
14771           int sym_width;
14772
14773           printf (_(" Global entries:\n"));
14774           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14775                   addr_size * 2, _("Address"),
14776                   _("Access"),
14777                   addr_size * 2, _("Initial"),
14778                   addr_size * 2, _("Sym.Val."),
14779                   _("Type"),
14780                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14781                   _("Ndx"), _("Name"));
14782
14783           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14784
14785           for (i = gotsym; i < symtabno; i++)
14786             {
14787               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14788               printf (" ");
14789
14790               if (dynamic_symbols == NULL)
14791                 printf (_("<no dynamic symbols>"));
14792               else if (i < num_dynamic_syms)
14793                 {
14794                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14795
14796                   print_vma (psym->st_value, LONG_HEX);
14797                   printf (" %-7s %3s ",
14798                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14799                           get_symbol_index_type (psym->st_shndx));
14800
14801                   if (VALID_DYNAMIC_NAME (psym->st_name))
14802                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14803                   else
14804                     printf (_("<corrupt: %14ld>"), psym->st_name);
14805                 }
14806               else
14807                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14808                         (unsigned long) i);
14809
14810               printf ("\n");
14811               if (ent == (bfd_vma) -1)
14812                 break;
14813             }
14814           printf ("\n");
14815         }
14816
14817     got_print_fail:
14818       if (data)
14819         free (data);
14820     }
14821
14822   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14823     {
14824       bfd_vma ent, end;
14825       size_t offset, rel_offset;
14826       unsigned long count, i;
14827       unsigned char * data;
14828       int addr_size, sym_width;
14829       Elf_Internal_Rela * rels;
14830
14831       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14832       if (pltrel == DT_RELA)
14833         {
14834           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14835             return 0;
14836         }
14837       else
14838         {
14839           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14840             return 0;
14841         }
14842
14843       ent = mips_pltgot;
14844       addr_size = (is_32bit_elf ? 4 : 8);
14845       end = mips_pltgot + (2 + count) * addr_size;
14846
14847       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14848       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14849                                          1, _("Procedure Linkage Table data"));
14850       if (data == NULL)
14851         return 0;
14852
14853       printf ("\nPLT GOT:\n\n");
14854       printf (_(" Reserved entries:\n"));
14855       printf (_("  %*s %*s Purpose\n"),
14856               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14857       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14858       printf (_(" PLT lazy resolver\n"));
14859       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14860       printf (_(" Module pointer\n"));
14861       printf ("\n");
14862
14863       printf (_(" Entries:\n"));
14864       printf ("  %*s %*s %*s %-7s %3s %s\n",
14865               addr_size * 2, _("Address"),
14866               addr_size * 2, _("Initial"),
14867               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14868       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14869       for (i = 0; i < count; i++)
14870         {
14871           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14872
14873           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14874           printf (" ");
14875
14876           if (idx >= num_dynamic_syms)
14877             printf (_("<corrupt symbol index: %lu>"), idx);
14878           else
14879             {
14880               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14881
14882               print_vma (psym->st_value, LONG_HEX);
14883               printf (" %-7s %3s ",
14884                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14885                       get_symbol_index_type (psym->st_shndx));
14886               if (VALID_DYNAMIC_NAME (psym->st_name))
14887                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14888               else
14889                 printf (_("<corrupt: %14ld>"), psym->st_name);
14890             }
14891           printf ("\n");
14892         }
14893       printf ("\n");
14894
14895       if (data)
14896         free (data);
14897       free (rels);
14898     }
14899
14900   return 1;
14901 }
14902
14903 static int
14904 process_nds32_specific (FILE * file)
14905 {
14906   Elf_Internal_Shdr *sect = NULL;
14907
14908   sect = find_section (".nds32_e_flags");
14909   if (sect != NULL)
14910     {
14911       unsigned int *flag;
14912
14913       printf ("\nNDS32 elf flags section:\n");
14914       flag = get_data (NULL, file, sect->sh_offset, 1,
14915                        sect->sh_size, _("NDS32 elf flags section"));
14916
14917       switch ((*flag) & 0x3)
14918         {
14919         case 0:
14920           printf ("(VEC_SIZE):\tNo entry.\n");
14921           break;
14922         case 1:
14923           printf ("(VEC_SIZE):\t4 bytes\n");
14924           break;
14925         case 2:
14926           printf ("(VEC_SIZE):\t16 bytes\n");
14927           break;
14928         case 3:
14929           printf ("(VEC_SIZE):\treserved\n");
14930           break;
14931         }
14932     }
14933
14934   return TRUE;
14935 }
14936
14937 static int
14938 process_gnu_liblist (FILE * file)
14939 {
14940   Elf_Internal_Shdr * section;
14941   Elf_Internal_Shdr * string_sec;
14942   Elf32_External_Lib * elib;
14943   char * strtab;
14944   size_t strtab_size;
14945   size_t cnt;
14946   unsigned i;
14947
14948   if (! do_arch)
14949     return 0;
14950
14951   for (i = 0, section = section_headers;
14952        i < elf_header.e_shnum;
14953        i++, section++)
14954     {
14955       switch (section->sh_type)
14956         {
14957         case SHT_GNU_LIBLIST:
14958           if (section->sh_link >= elf_header.e_shnum)
14959             break;
14960
14961           elib = (Elf32_External_Lib *)
14962               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14963                         _("liblist section data"));
14964
14965           if (elib == NULL)
14966             break;
14967           string_sec = section_headers + section->sh_link;
14968
14969           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14970                                       string_sec->sh_size,
14971                                       _("liblist string table"));
14972           if (strtab == NULL
14973               || section->sh_entsize != sizeof (Elf32_External_Lib))
14974             {
14975               free (elib);
14976               free (strtab);
14977               break;
14978             }
14979           strtab_size = string_sec->sh_size;
14980
14981           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14982                   printable_section_name (section),
14983                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14984
14985           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14986
14987           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14988                ++cnt)
14989             {
14990               Elf32_Lib liblist;
14991               time_t atime;
14992               char timebuf[20];
14993               struct tm * tmp;
14994
14995               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14996               atime = BYTE_GET (elib[cnt].l_time_stamp);
14997               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14998               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14999               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15000
15001               tmp = gmtime (&atime);
15002               snprintf (timebuf, sizeof (timebuf),
15003                         "%04u-%02u-%02uT%02u:%02u:%02u",
15004                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15005                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15006
15007               printf ("%3lu: ", (unsigned long) cnt);
15008               if (do_wide)
15009                 printf ("%-20s", liblist.l_name < strtab_size
15010                         ? strtab + liblist.l_name : _("<corrupt>"));
15011               else
15012                 printf ("%-20.20s", liblist.l_name < strtab_size
15013                         ? strtab + liblist.l_name : _("<corrupt>"));
15014               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15015                       liblist.l_version, liblist.l_flags);
15016             }
15017
15018           free (elib);
15019           free (strtab);
15020         }
15021     }
15022
15023   return 1;
15024 }
15025
15026 static const char *
15027 get_note_type (unsigned e_type)
15028 {
15029   static char buff[64];
15030
15031   if (elf_header.e_type == ET_CORE)
15032     switch (e_type)
15033       {
15034       case NT_AUXV:
15035         return _("NT_AUXV (auxiliary vector)");
15036       case NT_PRSTATUS:
15037         return _("NT_PRSTATUS (prstatus structure)");
15038       case NT_FPREGSET:
15039         return _("NT_FPREGSET (floating point registers)");
15040       case NT_PRPSINFO:
15041         return _("NT_PRPSINFO (prpsinfo structure)");
15042       case NT_TASKSTRUCT:
15043         return _("NT_TASKSTRUCT (task structure)");
15044       case NT_PRXFPREG:
15045         return _("NT_PRXFPREG (user_xfpregs structure)");
15046       case NT_PPC_VMX:
15047         return _("NT_PPC_VMX (ppc Altivec registers)");
15048       case NT_PPC_VSX:
15049         return _("NT_PPC_VSX (ppc VSX registers)");
15050       case NT_386_TLS:
15051         return _("NT_386_TLS (x86 TLS information)");
15052       case NT_386_IOPERM:
15053         return _("NT_386_IOPERM (x86 I/O permissions)");
15054       case NT_X86_XSTATE:
15055         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15056       case NT_S390_HIGH_GPRS:
15057         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15058       case NT_S390_TIMER:
15059         return _("NT_S390_TIMER (s390 timer register)");
15060       case NT_S390_TODCMP:
15061         return _("NT_S390_TODCMP (s390 TOD comparator register)");
15062       case NT_S390_TODPREG:
15063         return _("NT_S390_TODPREG (s390 TOD programmable register)");
15064       case NT_S390_CTRS:
15065         return _("NT_S390_CTRS (s390 control registers)");
15066       case NT_S390_PREFIX:
15067         return _("NT_S390_PREFIX (s390 prefix register)");
15068       case NT_S390_LAST_BREAK:
15069         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15070       case NT_S390_SYSTEM_CALL:
15071         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15072       case NT_S390_TDB:
15073         return _("NT_S390_TDB (s390 transaction diagnostic block)");
15074       case NT_S390_VXRS_LOW:
15075         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15076       case NT_S390_VXRS_HIGH:
15077         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15078       case NT_ARM_VFP:
15079         return _("NT_ARM_VFP (arm VFP registers)");
15080       case NT_ARM_TLS:
15081         return _("NT_ARM_TLS (AArch TLS registers)");
15082       case NT_ARM_HW_BREAK:
15083         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15084       case NT_ARM_HW_WATCH:
15085         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15086       case NT_PSTATUS:
15087         return _("NT_PSTATUS (pstatus structure)");
15088       case NT_FPREGS:
15089         return _("NT_FPREGS (floating point registers)");
15090       case NT_PSINFO:
15091         return _("NT_PSINFO (psinfo structure)");
15092       case NT_LWPSTATUS:
15093         return _("NT_LWPSTATUS (lwpstatus_t structure)");
15094       case NT_LWPSINFO:
15095         return _("NT_LWPSINFO (lwpsinfo_t structure)");
15096       case NT_WIN32PSTATUS:
15097         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15098       case NT_SIGINFO:
15099         return _("NT_SIGINFO (siginfo_t data)");
15100       case NT_FILE:
15101         return _("NT_FILE (mapped files)");
15102       default:
15103         break;
15104       }
15105   else
15106     switch (e_type)
15107       {
15108       case NT_VERSION:
15109         return _("NT_VERSION (version)");
15110       case NT_ARCH:
15111         return _("NT_ARCH (architecture)");
15112       default:
15113         break;
15114       }
15115
15116   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15117   return buff;
15118 }
15119
15120 static int
15121 print_core_note (Elf_Internal_Note *pnote)
15122 {
15123   unsigned int addr_size = is_32bit_elf ? 4 : 8;
15124   bfd_vma count, page_size;
15125   unsigned char *descdata, *filenames, *descend;
15126
15127   if (pnote->type != NT_FILE)
15128     return 1;
15129
15130 #ifndef BFD64
15131   if (!is_32bit_elf)
15132     {
15133       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
15134       /* Still "successful".  */
15135       return 1;
15136     }
15137 #endif
15138
15139   if (pnote->descsz < 2 * addr_size)
15140     {
15141       printf (_("    Malformed note - too short for header\n"));
15142       return 0;
15143     }
15144
15145   descdata = (unsigned char *) pnote->descdata;
15146   descend = descdata + pnote->descsz;
15147
15148   if (descdata[pnote->descsz - 1] != '\0')
15149     {
15150       printf (_("    Malformed note - does not end with \\0\n"));
15151       return 0;
15152     }
15153
15154   count = byte_get (descdata, addr_size);
15155   descdata += addr_size;
15156
15157   page_size = byte_get (descdata, addr_size);
15158   descdata += addr_size;
15159
15160   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15161     {
15162       printf (_("    Malformed note - too short for supplied file count\n"));
15163       return 0;
15164     }
15165
15166   printf (_("    Page size: "));
15167   print_vma (page_size, DEC);
15168   printf ("\n");
15169
15170   printf (_("    %*s%*s%*s\n"),
15171           (int) (2 + 2 * addr_size), _("Start"),
15172           (int) (4 + 2 * addr_size), _("End"),
15173           (int) (4 + 2 * addr_size), _("Page Offset"));
15174   filenames = descdata + count * 3 * addr_size;
15175   while (count-- > 0)
15176     {
15177       bfd_vma start, end, file_ofs;
15178
15179       if (filenames == descend)
15180         {
15181           printf (_("    Malformed note - filenames end too early\n"));
15182           return 0;
15183         }
15184
15185       start = byte_get (descdata, addr_size);
15186       descdata += addr_size;
15187       end = byte_get (descdata, addr_size);
15188       descdata += addr_size;
15189       file_ofs = byte_get (descdata, addr_size);
15190       descdata += addr_size;
15191
15192       printf ("    ");
15193       print_vma (start, FULL_HEX);
15194       printf ("  ");
15195       print_vma (end, FULL_HEX);
15196       printf ("  ");
15197       print_vma (file_ofs, FULL_HEX);
15198       printf ("\n        %s\n", filenames);
15199
15200       filenames += 1 + strlen ((char *) filenames);
15201     }
15202
15203   return 1;
15204 }
15205
15206 static const char *
15207 get_gnu_elf_note_type (unsigned e_type)
15208 {
15209   static char buff[64];
15210
15211   switch (e_type)
15212     {
15213     case NT_GNU_ABI_TAG:
15214       return _("NT_GNU_ABI_TAG (ABI version tag)");
15215     case NT_GNU_HWCAP:
15216       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15217     case NT_GNU_BUILD_ID:
15218       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15219     case NT_GNU_GOLD_VERSION:
15220       return _("NT_GNU_GOLD_VERSION (gold version)");
15221     default:
15222       break;
15223     }
15224
15225   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15226   return buff;
15227 }
15228
15229 static int
15230 print_gnu_note (Elf_Internal_Note *pnote)
15231 {
15232   switch (pnote->type)
15233     {
15234     case NT_GNU_BUILD_ID:
15235       {
15236         unsigned long i;
15237
15238         printf (_("    Build ID: "));
15239         for (i = 0; i < pnote->descsz; ++i)
15240           printf ("%02x", pnote->descdata[i] & 0xff);
15241         printf ("\n");
15242       }
15243       break;
15244
15245     case NT_GNU_ABI_TAG:
15246       {
15247         unsigned long os, major, minor, subminor;
15248         const char *osname;
15249
15250         /* PR 17531: file: 030-599401-0.004.  */
15251         if (pnote->descsz < 16)
15252           {
15253             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15254             break;
15255           }
15256
15257         os = byte_get ((unsigned char *) pnote->descdata, 4);
15258         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15259         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15260         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15261
15262         switch (os)
15263           {
15264           case GNU_ABI_TAG_LINUX:
15265             osname = "Linux";
15266             break;
15267           case GNU_ABI_TAG_HURD:
15268             osname = "Hurd";
15269             break;
15270           case GNU_ABI_TAG_SOLARIS:
15271             osname = "Solaris";
15272             break;
15273           case GNU_ABI_TAG_FREEBSD:
15274             osname = "FreeBSD";
15275             break;
15276           case GNU_ABI_TAG_NETBSD:
15277             osname = "NetBSD";
15278             break;
15279           case GNU_ABI_TAG_SYLLABLE:
15280             osname = "Syllable";
15281             break;
15282           case GNU_ABI_TAG_NACL:
15283             osname = "NaCl";
15284             break;
15285           default:
15286             osname = "Unknown";
15287             break;
15288           }
15289
15290         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15291                 major, minor, subminor);
15292       }
15293       break;
15294
15295     case NT_GNU_GOLD_VERSION:
15296       {
15297         unsigned long i;
15298
15299         printf (_("    Version: "));
15300         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15301           printf ("%c", pnote->descdata[i]);
15302         printf ("\n");
15303       }
15304       break;
15305     }
15306
15307   return 1;
15308 }
15309
15310 static const char *
15311 get_v850_elf_note_type (enum v850_notes n_type)
15312 {
15313   static char buff[64];
15314
15315   switch (n_type)
15316     {
15317     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15318     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15319     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15320     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15321     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15322     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15323     default:
15324       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15325       return buff;
15326     }
15327 }
15328
15329 static int
15330 print_v850_note (Elf_Internal_Note * pnote)
15331 {
15332   unsigned int val;
15333
15334   if (pnote->descsz != 4)
15335     return 0;
15336   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15337
15338   if (val == 0)
15339     {
15340       printf (_("not set\n"));
15341       return 1;
15342     }
15343
15344   switch (pnote->type)
15345     {
15346     case V850_NOTE_ALIGNMENT:
15347       switch (val)
15348         {
15349         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15350         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15351         }
15352       break;
15353
15354     case V850_NOTE_DATA_SIZE:
15355       switch (val)
15356         {
15357         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15358         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15359         }
15360       break;
15361
15362     case V850_NOTE_FPU_INFO:
15363       switch (val)
15364         {
15365         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15366         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15367         }
15368       break;
15369
15370     case V850_NOTE_MMU_INFO:
15371     case V850_NOTE_CACHE_INFO:
15372     case V850_NOTE_SIMD_INFO:
15373       if (val == EF_RH850_SIMD)
15374         {
15375           printf (_("yes\n"));
15376           return 1;
15377         }
15378       break;
15379
15380     default:
15381       /* An 'unknown note type' message will already have been displayed.  */
15382       break;
15383     }
15384
15385   printf (_("unknown value: %x\n"), val);
15386   return 0;
15387 }
15388
15389 static int
15390 process_netbsd_elf_note (Elf_Internal_Note * pnote)
15391 {
15392   unsigned int version;
15393
15394   switch (pnote->type)
15395     {
15396     case NT_NETBSD_IDENT:
15397       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15398       if ((version / 10000) % 100)
15399         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15400                 version, version / 100000000, (version / 1000000) % 100,
15401                 (version / 10000) % 100 > 26 ? "Z" : "",
15402                 'A' + (version / 10000) % 26);
15403       else
15404         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15405                 version, version / 100000000, (version / 1000000) % 100,
15406                 (version / 100) % 100);
15407       return 1;
15408
15409     case NT_NETBSD_MARCH:
15410       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15411               pnote->descdata);
15412       return 1;
15413
15414     default:
15415       break;
15416     }
15417
15418   printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15419           pnote->type);
15420   return 1;
15421 }
15422
15423 static const char *
15424 get_freebsd_elfcore_note_type (unsigned e_type)
15425 {
15426   switch (e_type)
15427     {
15428     case NT_FREEBSD_THRMISC:
15429       return _("NT_THRMISC (thrmisc structure)");
15430     case NT_FREEBSD_PROCSTAT_PROC:
15431       return _("NT_PROCSTAT_PROC (proc data)");
15432     case NT_FREEBSD_PROCSTAT_FILES:
15433       return _("NT_PROCSTAT_FILES (files data)");
15434     case NT_FREEBSD_PROCSTAT_VMMAP:
15435       return _("NT_PROCSTAT_VMMAP (vmmap data)");
15436     case NT_FREEBSD_PROCSTAT_GROUPS:
15437       return _("NT_PROCSTAT_GROUPS (groups data)");
15438     case NT_FREEBSD_PROCSTAT_UMASK:
15439       return _("NT_PROCSTAT_UMASK (umask data)");
15440     case NT_FREEBSD_PROCSTAT_RLIMIT:
15441       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15442     case NT_FREEBSD_PROCSTAT_OSREL:
15443       return _("NT_PROCSTAT_OSREL (osreldate data)");
15444     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15445       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15446     case NT_FREEBSD_PROCSTAT_AUXV:
15447       return _("NT_PROCSTAT_AUXV (auxv data)");
15448     }
15449   return get_note_type (e_type);
15450 }
15451
15452 static const char *
15453 get_netbsd_elfcore_note_type (unsigned e_type)
15454 {
15455   static char buff[64];
15456
15457   if (e_type == NT_NETBSDCORE_PROCINFO)
15458     {
15459       /* NetBSD core "procinfo" structure.  */
15460       return _("NetBSD procinfo structure");
15461     }
15462
15463   /* As of Jan 2002 there are no other machine-independent notes
15464      defined for NetBSD core files.  If the note type is less
15465      than the start of the machine-dependent note types, we don't
15466      understand it.  */
15467
15468   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15469     {
15470       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15471       return buff;
15472     }
15473
15474   switch (elf_header.e_machine)
15475     {
15476     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15477        and PT_GETFPREGS == mach+2.  */
15478
15479     case EM_OLD_ALPHA:
15480     case EM_ALPHA:
15481     case EM_SPARC:
15482     case EM_SPARC32PLUS:
15483     case EM_SPARCV9:
15484       switch (e_type)
15485         {
15486         case NT_NETBSDCORE_FIRSTMACH + 0:
15487           return _("PT_GETREGS (reg structure)");
15488         case NT_NETBSDCORE_FIRSTMACH + 2:
15489           return _("PT_GETFPREGS (fpreg structure)");
15490         default:
15491           break;
15492         }
15493       break;
15494
15495     /* On all other arch's, PT_GETREGS == mach+1 and
15496        PT_GETFPREGS == mach+3.  */
15497     default:
15498       switch (e_type)
15499         {
15500         case NT_NETBSDCORE_FIRSTMACH + 1:
15501           return _("PT_GETREGS (reg structure)");
15502         case NT_NETBSDCORE_FIRSTMACH + 3:
15503           return _("PT_GETFPREGS (fpreg structure)");
15504         default:
15505           break;
15506         }
15507     }
15508
15509   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15510             e_type - NT_NETBSDCORE_FIRSTMACH);
15511   return buff;
15512 }
15513
15514 static const char *
15515 get_stapsdt_note_type (unsigned e_type)
15516 {
15517   static char buff[64];
15518
15519   switch (e_type)
15520     {
15521     case NT_STAPSDT:
15522       return _("NT_STAPSDT (SystemTap probe descriptors)");
15523
15524     default:
15525       break;
15526     }
15527
15528   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15529   return buff;
15530 }
15531
15532 static int
15533 print_stapsdt_note (Elf_Internal_Note *pnote)
15534 {
15535   int addr_size = is_32bit_elf ? 4 : 8;
15536   char *data = pnote->descdata;
15537   char *data_end = pnote->descdata + pnote->descsz;
15538   bfd_vma pc, base_addr, semaphore;
15539   char *provider, *probe, *arg_fmt;
15540
15541   pc = byte_get ((unsigned char *) data, addr_size);
15542   data += addr_size;
15543   base_addr = byte_get ((unsigned char *) data, addr_size);
15544   data += addr_size;
15545   semaphore = byte_get ((unsigned char *) data, addr_size);
15546   data += addr_size;
15547
15548   provider = data;
15549   data += strlen (data) + 1;
15550   probe = data;
15551   data += strlen (data) + 1;
15552   arg_fmt = data;
15553   data += strlen (data) + 1;
15554
15555   printf (_("    Provider: %s\n"), provider);
15556   printf (_("    Name: %s\n"), probe);
15557   printf (_("    Location: "));
15558   print_vma (pc, FULL_HEX);
15559   printf (_(", Base: "));
15560   print_vma (base_addr, FULL_HEX);
15561   printf (_(", Semaphore: "));
15562   print_vma (semaphore, FULL_HEX);
15563   printf ("\n");
15564   printf (_("    Arguments: %s\n"), arg_fmt);
15565
15566   return data == data_end;
15567 }
15568
15569 static const char *
15570 get_ia64_vms_note_type (unsigned e_type)
15571 {
15572   static char buff[64];
15573
15574   switch (e_type)
15575     {
15576     case NT_VMS_MHD:
15577       return _("NT_VMS_MHD (module header)");
15578     case NT_VMS_LNM:
15579       return _("NT_VMS_LNM (language name)");
15580     case NT_VMS_SRC:
15581       return _("NT_VMS_SRC (source files)");
15582     case NT_VMS_TITLE:
15583       return "NT_VMS_TITLE";
15584     case NT_VMS_EIDC:
15585       return _("NT_VMS_EIDC (consistency check)");
15586     case NT_VMS_FPMODE:
15587       return _("NT_VMS_FPMODE (FP mode)");
15588     case NT_VMS_LINKTIME:
15589       return "NT_VMS_LINKTIME";
15590     case NT_VMS_IMGNAM:
15591       return _("NT_VMS_IMGNAM (image name)");
15592     case NT_VMS_IMGID:
15593       return _("NT_VMS_IMGID (image id)");
15594     case NT_VMS_LINKID:
15595       return _("NT_VMS_LINKID (link id)");
15596     case NT_VMS_IMGBID:
15597       return _("NT_VMS_IMGBID (build id)");
15598     case NT_VMS_GSTNAM:
15599       return _("NT_VMS_GSTNAM (sym table name)");
15600     case NT_VMS_ORIG_DYN:
15601       return "NT_VMS_ORIG_DYN";
15602     case NT_VMS_PATCHTIME:
15603       return "NT_VMS_PATCHTIME";
15604     default:
15605       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15606       return buff;
15607     }
15608 }
15609
15610 static int
15611 print_ia64_vms_note (Elf_Internal_Note * pnote)
15612 {
15613   switch (pnote->type)
15614     {
15615     case NT_VMS_MHD:
15616       if (pnote->descsz > 36)
15617         {
15618           size_t l = strlen (pnote->descdata + 34);
15619           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15620           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15621           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15622           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15623         }
15624       else
15625         printf (_("    Invalid size\n"));
15626       break;
15627     case NT_VMS_LNM:
15628       printf (_("   Language: %s\n"), pnote->descdata);
15629       break;
15630 #ifdef BFD64
15631     case NT_VMS_FPMODE:
15632       printf (_("   Floating Point mode: "));
15633       printf ("0x%016" BFD_VMA_FMT "x\n",
15634               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15635       break;
15636     case NT_VMS_LINKTIME:
15637       printf (_("   Link time: "));
15638       print_vms_time
15639         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15640       printf ("\n");
15641       break;
15642     case NT_VMS_PATCHTIME:
15643       printf (_("   Patch time: "));
15644       print_vms_time
15645         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15646       printf ("\n");
15647       break;
15648     case NT_VMS_ORIG_DYN:
15649       printf (_("   Major id: %u,  minor id: %u\n"),
15650               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15651               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15652       printf (_("   Last modified  : "));
15653       print_vms_time
15654         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15655       printf (_("\n   Link flags  : "));
15656       printf ("0x%016" BFD_VMA_FMT "x\n",
15657               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15658       printf (_("   Header flags: 0x%08x\n"),
15659               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15660       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15661       break;
15662 #endif
15663     case NT_VMS_IMGNAM:
15664       printf (_("    Image name: %s\n"), pnote->descdata);
15665       break;
15666     case NT_VMS_GSTNAM:
15667       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15668       break;
15669     case NT_VMS_IMGID:
15670       printf (_("    Image id: %s\n"), pnote->descdata);
15671       break;
15672     case NT_VMS_LINKID:
15673       printf (_("    Linker id: %s\n"), pnote->descdata);
15674       break;
15675     default:
15676       break;
15677     }
15678   return 1;
15679 }
15680
15681 /* Note that by the ELF standard, the name field is already null byte
15682    terminated, and namesz includes the terminating null byte.
15683    I.E. the value of namesz for the name "FSF" is 4.
15684
15685    If the value of namesz is zero, there is no name present.  */
15686 static int
15687 process_note (Elf_Internal_Note * pnote)
15688 {
15689   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15690   const char * nt;
15691
15692   if (pnote->namesz == 0)
15693     /* If there is no note name, then use the default set of
15694        note type strings.  */
15695     nt = get_note_type (pnote->type);
15696
15697   else if (const_strneq (pnote->namedata, "GNU"))
15698     /* GNU-specific object file notes.  */
15699     nt = get_gnu_elf_note_type (pnote->type);
15700
15701   else if (const_strneq (pnote->namedata, "FreeBSD"))
15702     /* FreeBSD-specific core file notes.  */
15703     nt = get_freebsd_elfcore_note_type (pnote->type);
15704
15705   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15706     /* NetBSD-specific core file notes.  */
15707     nt = get_netbsd_elfcore_note_type (pnote->type);
15708
15709   else if (const_strneq (pnote->namedata, "NetBSD"))
15710     /* NetBSD-specific core file notes.  */
15711     return process_netbsd_elf_note (pnote);
15712
15713   else if (strneq (pnote->namedata, "SPU/", 4))
15714     {
15715       /* SPU-specific core file notes.  */
15716       nt = pnote->namedata + 4;
15717       name = "SPU";
15718     }
15719
15720   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15721     /* VMS/ia64-specific file notes.  */
15722     nt = get_ia64_vms_note_type (pnote->type);
15723
15724   else if (const_strneq (pnote->namedata, "stapsdt"))
15725     nt = get_stapsdt_note_type (pnote->type);
15726
15727   else
15728     /* Don't recognize this note name; just use the default set of
15729        note type strings.  */
15730     nt = get_note_type (pnote->type);
15731
15732   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15733
15734   if (const_strneq (pnote->namedata, "IPF/VMS"))
15735     return print_ia64_vms_note (pnote);
15736   else if (const_strneq (pnote->namedata, "GNU"))
15737     return print_gnu_note (pnote);
15738   else if (const_strneq (pnote->namedata, "stapsdt"))
15739     return print_stapsdt_note (pnote);
15740   else if (const_strneq (pnote->namedata, "CORE"))
15741     return print_core_note (pnote);
15742   else
15743     return 1;
15744 }
15745
15746
15747 static int
15748 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15749 {
15750   Elf_External_Note * pnotes;
15751   Elf_External_Note * external;
15752   char * end;
15753   int res = 1;
15754
15755   if (length <= 0)
15756     return 0;
15757
15758   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15759                                            _("notes"));
15760   if (pnotes == NULL)
15761     return 0;
15762
15763   external = pnotes;
15764
15765   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15766           (unsigned long) offset, (unsigned long) length);
15767   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15768
15769   end = (char *) pnotes + length;
15770   while ((char *) external < end)
15771     {
15772       Elf_Internal_Note inote;
15773       size_t min_notesz;
15774       char *next;
15775       char * temp = NULL;
15776       size_t data_remaining = end - (char *) external;
15777
15778       if (!is_ia64_vms ())
15779         {
15780           /* PR binutils/15191
15781              Make sure that there is enough data to read.  */
15782           min_notesz = offsetof (Elf_External_Note, name);
15783           if (data_remaining < min_notesz)
15784             {
15785               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15786                     (int) data_remaining);
15787               break;
15788             }
15789           inote.type     = BYTE_GET (external->type);
15790           inote.namesz   = BYTE_GET (external->namesz);
15791           inote.namedata = external->name;
15792           inote.descsz   = BYTE_GET (external->descsz);
15793           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15794           /* PR 17531: file: 3443835e.  */
15795           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15796             {
15797               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15798               inote.descdata = inote.namedata;
15799               inote.namesz   = 0;
15800             }
15801
15802           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15803           next = inote.descdata + align_power (inote.descsz, 2);
15804         }
15805       else
15806         {
15807           Elf64_External_VMS_Note *vms_external;
15808
15809           /* PR binutils/15191
15810              Make sure that there is enough data to read.  */
15811           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15812           if (data_remaining < min_notesz)
15813             {
15814               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15815                     (int) data_remaining);
15816               break;
15817             }
15818
15819           vms_external = (Elf64_External_VMS_Note *) external;
15820           inote.type     = BYTE_GET (vms_external->type);
15821           inote.namesz   = BYTE_GET (vms_external->namesz);
15822           inote.namedata = vms_external->name;
15823           inote.descsz   = BYTE_GET (vms_external->descsz);
15824           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15825           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15826           next = inote.descdata + align_power (inote.descsz, 3);
15827         }
15828
15829       if (inote.descdata < (char *) external + min_notesz
15830           || next < (char *) external + min_notesz
15831           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15832           || inote.namedata + inote.namesz < inote.namedata
15833           || inote.descdata + inote.descsz < inote.descdata
15834           || data_remaining < (size_t)(next - (char *) external))
15835         {
15836           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15837                 (unsigned long) ((char *) external - (char *) pnotes));
15838           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15839                 inote.type, inote.namesz, inote.descsz);
15840           break;
15841         }
15842
15843       external = (Elf_External_Note *) next;
15844
15845       /* Verify that name is null terminated.  It appears that at least
15846          one version of Linux (RedHat 6.0) generates corefiles that don't
15847          comply with the ELF spec by failing to include the null byte in
15848          namesz.  */
15849       if (inote.namedata[inote.namesz - 1] != '\0')
15850         {
15851           temp = (char *) malloc (inote.namesz + 1);
15852           if (temp == NULL)
15853             {
15854               error (_("Out of memory allocating space for inote name\n"));
15855               res = 0;
15856               break;
15857             }
15858
15859           strncpy (temp, inote.namedata, inote.namesz);
15860           temp[inote.namesz] = 0;
15861
15862           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15863           inote.namedata = temp;
15864         }
15865
15866       res &= process_note (& inote);
15867
15868       if (temp != NULL)
15869         {
15870           free (temp);
15871           temp = NULL;
15872         }
15873     }
15874
15875   free (pnotes);
15876
15877   return res;
15878 }
15879
15880 static int
15881 process_corefile_note_segments (FILE * file)
15882 {
15883   Elf_Internal_Phdr * segment;
15884   unsigned int i;
15885   int res = 1;
15886
15887   if (! get_program_headers (file))
15888       return 0;
15889
15890   for (i = 0, segment = program_headers;
15891        i < elf_header.e_phnum;
15892        i++, segment++)
15893     {
15894       if (segment->p_type == PT_NOTE)
15895         res &= process_corefile_note_segment (file,
15896                                               (bfd_vma) segment->p_offset,
15897                                               (bfd_vma) segment->p_filesz);
15898     }
15899
15900   return res;
15901 }
15902
15903 static int
15904 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15905 {
15906   Elf_External_Note * pnotes;
15907   Elf_External_Note * external;
15908   char * end;
15909   int res = 1;
15910
15911   if (length <= 0)
15912     return 0;
15913
15914   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15915                                            _("v850 notes"));
15916   if (pnotes == NULL)
15917     return 0;
15918
15919   external = pnotes;
15920   end = (char*) pnotes + length;
15921
15922   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15923           (unsigned long) offset, (unsigned long) length);
15924
15925   while ((char *) external + sizeof (Elf_External_Note) < end)
15926     {
15927       Elf_External_Note * next;
15928       Elf_Internal_Note inote;
15929
15930       inote.type     = BYTE_GET (external->type);
15931       inote.namesz   = BYTE_GET (external->namesz);
15932       inote.namedata = external->name;
15933       inote.descsz   = BYTE_GET (external->descsz);
15934       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15935       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15936
15937       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15938         {
15939           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15940           inote.descdata = inote.namedata;
15941           inote.namesz   = 0;
15942         }
15943
15944       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15945
15946       if (   ((char *) next > end)
15947           || ((char *) next <  (char *) pnotes))
15948         {
15949           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15950                 (unsigned long) ((char *) external - (char *) pnotes));
15951           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15952                 inote.type, inote.namesz, inote.descsz);
15953           break;
15954         }
15955
15956       external = next;
15957
15958       /* Prevent out-of-bounds indexing.  */
15959       if (   inote.namedata + inote.namesz > end
15960           || inote.namedata + inote.namesz < inote.namedata)
15961         {
15962           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15963                 (unsigned long) ((char *) external - (char *) pnotes));
15964           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15965                 inote.type, inote.namesz, inote.descsz);
15966           break;
15967         }
15968
15969       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15970
15971       if (! print_v850_note (& inote))
15972         {
15973           res = 0;
15974           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15975                   inote.namesz, inote.descsz);
15976         }
15977     }
15978
15979   free (pnotes);
15980
15981   return res;
15982 }
15983
15984 static int
15985 process_note_sections (FILE * file)
15986 {
15987   Elf_Internal_Shdr * section;
15988   unsigned long i;
15989   int n = 0;
15990   int res = 1;
15991
15992   for (i = 0, section = section_headers;
15993        i < elf_header.e_shnum && section != NULL;
15994        i++, section++)
15995     {
15996       if (section->sh_type == SHT_NOTE)
15997         {
15998           res &= process_corefile_note_segment (file,
15999                                                 (bfd_vma) section->sh_offset,
16000                                                 (bfd_vma) section->sh_size);
16001           n++;
16002         }
16003
16004       if ((   elf_header.e_machine == EM_V800
16005            || elf_header.e_machine == EM_V850
16006            || elf_header.e_machine == EM_CYGNUS_V850)
16007           && section->sh_type == SHT_RENESAS_INFO)
16008         {
16009           res &= process_v850_notes (file,
16010                                      (bfd_vma) section->sh_offset,
16011                                      (bfd_vma) section->sh_size);
16012           n++;
16013         }
16014     }
16015
16016   if (n == 0)
16017     /* Try processing NOTE segments instead.  */
16018     return process_corefile_note_segments (file);
16019
16020   return res;
16021 }
16022
16023 static int
16024 process_notes (FILE * file)
16025 {
16026   /* If we have not been asked to display the notes then do nothing.  */
16027   if (! do_notes)
16028     return 1;
16029
16030   if (elf_header.e_type != ET_CORE)
16031     return process_note_sections (file);
16032
16033   /* No program headers means no NOTE segment.  */
16034   if (elf_header.e_phnum > 0)
16035     return process_corefile_note_segments (file);
16036
16037   printf (_("No note segments present in the core file.\n"));
16038   return 1;
16039 }
16040
16041 static int
16042 process_arch_specific (FILE * file)
16043 {
16044   if (! do_arch)
16045     return 1;
16046
16047   switch (elf_header.e_machine)
16048     {
16049     case EM_ARM:
16050       return process_arm_specific (file);
16051     case EM_MIPS:
16052     case EM_MIPS_RS3_LE:
16053       return process_mips_specific (file);
16054       break;
16055     case EM_NDS32:
16056       return process_nds32_specific (file);
16057       break;
16058     case EM_PPC:
16059       return process_power_specific (file);
16060       break;
16061     case EM_S390:
16062     case EM_S390_OLD:
16063       return process_s390_specific (file);
16064       break;
16065     case EM_SPARC:
16066     case EM_SPARC32PLUS:
16067     case EM_SPARCV9:
16068       return process_sparc_specific (file);
16069       break;
16070     case EM_TI_C6000:
16071       return process_tic6x_specific (file);
16072       break;
16073     case EM_MSP430:
16074       return process_msp430x_specific (file);
16075     default:
16076       break;
16077     }
16078   return 1;
16079 }
16080
16081 static int
16082 get_file_header (FILE * file)
16083 {
16084   /* Read in the identity array.  */
16085   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
16086     return 0;
16087
16088   /* Determine how to read the rest of the header.  */
16089   switch (elf_header.e_ident[EI_DATA])
16090     {
16091     default: /* fall through */
16092     case ELFDATANONE: /* fall through */
16093     case ELFDATA2LSB:
16094       byte_get = byte_get_little_endian;
16095       byte_put = byte_put_little_endian;
16096       break;
16097     case ELFDATA2MSB:
16098       byte_get = byte_get_big_endian;
16099       byte_put = byte_put_big_endian;
16100       break;
16101     }
16102
16103   /* For now we only support 32 bit and 64 bit ELF files.  */
16104   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
16105
16106   /* Read in the rest of the header.  */
16107   if (is_32bit_elf)
16108     {
16109       Elf32_External_Ehdr ehdr32;
16110
16111       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16112         return 0;
16113
16114       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
16115       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
16116       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
16117       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
16118       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
16119       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
16120       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
16121       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
16122       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16123       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
16124       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16125       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
16126       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
16127     }
16128   else
16129     {
16130       Elf64_External_Ehdr ehdr64;
16131
16132       /* If we have been compiled with sizeof (bfd_vma) == 4, then
16133          we will not be able to cope with the 64bit data found in
16134          64 ELF files.  Detect this now and abort before we start
16135          overwriting things.  */
16136       if (sizeof (bfd_vma) < 8)
16137         {
16138           error (_("This instance of readelf has been built without support for a\n\
16139 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16140           return 0;
16141         }
16142
16143       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16144         return 0;
16145
16146       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
16147       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
16148       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
16149       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
16150       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
16151       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
16152       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
16153       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
16154       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16155       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
16156       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16157       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
16158       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
16159     }
16160
16161   if (elf_header.e_shoff)
16162     {
16163       /* There may be some extensions in the first section header.  Don't
16164          bomb if we can't read it.  */
16165       if (is_32bit_elf)
16166         get_32bit_section_headers (file, TRUE);
16167       else
16168         get_64bit_section_headers (file, TRUE);
16169     }
16170
16171   return 1;
16172 }
16173
16174 /* Process one ELF object file according to the command line options.
16175    This file may actually be stored in an archive.  The file is
16176    positioned at the start of the ELF object.  */
16177
16178 static int
16179 process_object (char * file_name, FILE * file)
16180 {
16181   unsigned int i;
16182
16183   if (! get_file_header (file))
16184     {
16185       error (_("%s: Failed to read file header\n"), file_name);
16186       return 1;
16187     }
16188
16189   /* Initialise per file variables.  */
16190   for (i = ARRAY_SIZE (version_info); i--;)
16191     version_info[i] = 0;
16192
16193   for (i = ARRAY_SIZE (dynamic_info); i--;)
16194     dynamic_info[i] = 0;
16195   dynamic_info_DT_GNU_HASH = 0;
16196
16197   /* Process the file.  */
16198   if (show_name)
16199     printf (_("\nFile: %s\n"), file_name);
16200
16201   /* Initialise the dump_sects array from the cmdline_dump_sects array.
16202      Note we do this even if cmdline_dump_sects is empty because we
16203      must make sure that the dump_sets array is zeroed out before each
16204      object file is processed.  */
16205   if (num_dump_sects > num_cmdline_dump_sects)
16206     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
16207
16208   if (num_cmdline_dump_sects > 0)
16209     {
16210       if (num_dump_sects == 0)
16211         /* A sneaky way of allocating the dump_sects array.  */
16212         request_dump_bynumber (num_cmdline_dump_sects, 0);
16213
16214       assert (num_dump_sects >= num_cmdline_dump_sects);
16215       memcpy (dump_sects, cmdline_dump_sects,
16216               num_cmdline_dump_sects * sizeof (* dump_sects));
16217     }
16218
16219   if (! process_file_header ())
16220     return 1;
16221
16222   if (! process_section_headers (file))
16223     {
16224       /* Without loaded section headers we cannot process lots of
16225          things.  */
16226       do_unwind = do_version = do_dump = do_arch = 0;
16227
16228       if (! do_using_dynamic)
16229         do_syms = do_dyn_syms = do_reloc = 0;
16230     }
16231
16232   if (! process_section_groups (file))
16233     {
16234       /* Without loaded section groups we cannot process unwind.  */
16235       do_unwind = 0;
16236     }
16237
16238   if (process_program_headers (file))
16239     process_dynamic_section (file);
16240
16241   process_relocs (file);
16242
16243   process_unwind (file);
16244
16245   process_symbol_table (file);
16246
16247   process_syminfo (file);
16248
16249   process_version_sections (file);
16250
16251   process_section_contents (file);
16252
16253   process_notes (file);
16254
16255   process_gnu_liblist (file);
16256
16257   process_arch_specific (file);
16258
16259   if (program_headers)
16260     {
16261       free (program_headers);
16262       program_headers = NULL;
16263     }
16264
16265   if (section_headers)
16266     {
16267       free (section_headers);
16268       section_headers = NULL;
16269     }
16270
16271   if (string_table)
16272     {
16273       free (string_table);
16274       string_table = NULL;
16275       string_table_length = 0;
16276     }
16277
16278   if (dynamic_strings)
16279     {
16280       free (dynamic_strings);
16281       dynamic_strings = NULL;
16282       dynamic_strings_length = 0;
16283     }
16284
16285   if (dynamic_symbols)
16286     {
16287       free (dynamic_symbols);
16288       dynamic_symbols = NULL;
16289       num_dynamic_syms = 0;
16290     }
16291
16292   if (dynamic_syminfo)
16293     {
16294       free (dynamic_syminfo);
16295       dynamic_syminfo = NULL;
16296     }
16297
16298   if (dynamic_section)
16299     {
16300       free (dynamic_section);
16301       dynamic_section = NULL;
16302     }
16303
16304   if (section_headers_groups)
16305     {
16306       free (section_headers_groups);
16307       section_headers_groups = NULL;
16308     }
16309
16310   if (section_groups)
16311     {
16312       struct group_list * g;
16313       struct group_list * next;
16314
16315       for (i = 0; i < group_count; i++)
16316         {
16317           for (g = section_groups [i].root; g != NULL; g = next)
16318             {
16319               next = g->next;
16320               free (g);
16321             }
16322         }
16323
16324       free (section_groups);
16325       section_groups = NULL;
16326     }
16327
16328   free_debug_memory ();
16329
16330   return 0;
16331 }
16332
16333 /* Process an ELF archive.
16334    On entry the file is positioned just after the ARMAG string.  */
16335
16336 static int
16337 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16338 {
16339   struct archive_info arch;
16340   struct archive_info nested_arch;
16341   size_t got;
16342   int ret;
16343
16344   show_name = 1;
16345
16346   /* The ARCH structure is used to hold information about this archive.  */
16347   arch.file_name = NULL;
16348   arch.file = NULL;
16349   arch.index_array = NULL;
16350   arch.sym_table = NULL;
16351   arch.longnames = NULL;
16352
16353   /* The NESTED_ARCH structure is used as a single-item cache of information
16354      about a nested archive (when members of a thin archive reside within
16355      another regular archive file).  */
16356   nested_arch.file_name = NULL;
16357   nested_arch.file = NULL;
16358   nested_arch.index_array = NULL;
16359   nested_arch.sym_table = NULL;
16360   nested_arch.longnames = NULL;
16361
16362   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16363     {
16364       ret = 1;
16365       goto out;
16366     }
16367
16368   if (do_archive_index)
16369     {
16370       if (arch.sym_table == NULL)
16371         error (_("%s: unable to dump the index as none was found\n"), file_name);
16372       else
16373         {
16374           unsigned long i, l;
16375           unsigned long current_pos;
16376
16377           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16378                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16379           current_pos = ftell (file);
16380
16381           for (i = l = 0; i < arch.index_num; i++)
16382             {
16383               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16384                 {
16385                   char * member_name;
16386
16387                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16388
16389                   if (member_name != NULL)
16390                     {
16391                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16392
16393                       if (qualified_name != NULL)
16394                         {
16395                           printf (_("Contents of binary %s at offset "), qualified_name);
16396                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16397                           putchar ('\n');
16398                           free (qualified_name);
16399                         }
16400                     }
16401                 }
16402
16403               if (l >= arch.sym_size)
16404                 {
16405                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16406                          file_name);
16407                   break;
16408                 }
16409               /* PR 17531: file: 0b6630b2.  */
16410               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16411               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16412             }
16413
16414           if (arch.uses_64bit_indicies)
16415             l = (l + 7) & ~ 7;
16416           else
16417             l += l & 1;
16418
16419           if (l < arch.sym_size)
16420             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16421                    file_name, arch.sym_size - l);
16422
16423           if (fseek (file, current_pos, SEEK_SET) != 0)
16424             {
16425               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16426               ret = 1;
16427               goto out;
16428             }
16429         }
16430
16431       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16432           && !do_segments && !do_header && !do_dump && !do_version
16433           && !do_histogram && !do_debugging && !do_arch && !do_notes
16434           && !do_section_groups && !do_dyn_syms)
16435         {
16436           ret = 0; /* Archive index only.  */
16437           goto out;
16438         }
16439     }
16440
16441   ret = 0;
16442
16443   while (1)
16444     {
16445       char * name;
16446       size_t namelen;
16447       char * qualified_name;
16448
16449       /* Read the next archive header.  */
16450       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16451         {
16452           error (_("%s: failed to seek to next archive header\n"), file_name);
16453           return 1;
16454         }
16455       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16456       if (got != sizeof arch.arhdr)
16457         {
16458           if (got == 0)
16459             break;
16460           error (_("%s: failed to read archive header\n"), file_name);
16461           ret = 1;
16462           break;
16463         }
16464       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16465         {
16466           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16467           ret = 1;
16468           break;
16469         }
16470
16471       arch.next_arhdr_offset += sizeof arch.arhdr;
16472
16473       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16474       if (archive_file_size & 01)
16475         ++archive_file_size;
16476
16477       name = get_archive_member_name (&arch, &nested_arch);
16478       if (name == NULL)
16479         {
16480           error (_("%s: bad archive file name\n"), file_name);
16481           ret = 1;
16482           break;
16483         }
16484       namelen = strlen (name);
16485
16486       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16487       if (qualified_name == NULL)
16488         {
16489           error (_("%s: bad archive file name\n"), file_name);
16490           ret = 1;
16491           break;
16492         }
16493
16494       if (is_thin_archive && arch.nested_member_origin == 0)
16495         {
16496           /* This is a proxy for an external member of a thin archive.  */
16497           FILE * member_file;
16498           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16499           if (member_file_name == NULL)
16500             {
16501               ret = 1;
16502               break;
16503             }
16504
16505           member_file = fopen (member_file_name, "rb");
16506           if (member_file == NULL)
16507             {
16508               error (_("Input file '%s' is not readable.\n"), member_file_name);
16509               free (member_file_name);
16510               ret = 1;
16511               break;
16512             }
16513
16514           archive_file_offset = arch.nested_member_origin;
16515
16516           ret |= process_object (qualified_name, member_file);
16517
16518           fclose (member_file);
16519           free (member_file_name);
16520         }
16521       else if (is_thin_archive)
16522         {
16523           /* PR 15140: Allow for corrupt thin archives.  */
16524           if (nested_arch.file == NULL)
16525             {
16526               error (_("%s: contains corrupt thin archive: %s\n"),
16527                      file_name, name);
16528               ret = 1;
16529               break;
16530             }
16531
16532           /* This is a proxy for a member of a nested archive.  */
16533           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16534
16535           /* The nested archive file will have been opened and setup by
16536              get_archive_member_name.  */
16537           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16538             {
16539               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16540               ret = 1;
16541               break;
16542             }
16543
16544           ret |= process_object (qualified_name, nested_arch.file);
16545         }
16546       else
16547         {
16548           archive_file_offset = arch.next_arhdr_offset;
16549           arch.next_arhdr_offset += archive_file_size;
16550
16551           ret |= process_object (qualified_name, file);
16552         }
16553
16554       if (dump_sects != NULL)
16555         {
16556           free (dump_sects);
16557           dump_sects = NULL;
16558           num_dump_sects = 0;
16559         }
16560
16561       free (qualified_name);
16562     }
16563
16564  out:
16565   if (nested_arch.file != NULL)
16566     fclose (nested_arch.file);
16567   release_archive (&nested_arch);
16568   release_archive (&arch);
16569
16570   return ret;
16571 }
16572
16573 static int
16574 process_file (char * file_name)
16575 {
16576   FILE * file;
16577   struct stat statbuf;
16578   char armag[SARMAG];
16579   int ret;
16580
16581   if (stat (file_name, &statbuf) < 0)
16582     {
16583       if (errno == ENOENT)
16584         error (_("'%s': No such file\n"), file_name);
16585       else
16586         error (_("Could not locate '%s'.  System error message: %s\n"),
16587                file_name, strerror (errno));
16588       return 1;
16589     }
16590
16591   if (! S_ISREG (statbuf.st_mode))
16592     {
16593       error (_("'%s' is not an ordinary file\n"), file_name);
16594       return 1;
16595     }
16596
16597   file = fopen (file_name, "rb");
16598   if (file == NULL)
16599     {
16600       error (_("Input file '%s' is not readable.\n"), file_name);
16601       return 1;
16602     }
16603
16604   if (fread (armag, SARMAG, 1, file) != 1)
16605     {
16606       error (_("%s: Failed to read file's magic number\n"), file_name);
16607       fclose (file);
16608       return 1;
16609     }
16610
16611   current_file_size = (bfd_size_type) statbuf.st_size;
16612
16613   if (memcmp (armag, ARMAG, SARMAG) == 0)
16614     ret = process_archive (file_name, file, FALSE);
16615   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16616     ret = process_archive (file_name, file, TRUE);
16617   else
16618     {
16619       if (do_archive_index)
16620         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16621                file_name);
16622
16623       rewind (file);
16624       archive_file_size = archive_file_offset = 0;
16625       ret = process_object (file_name, file);
16626     }
16627
16628   fclose (file);
16629
16630   current_file_size = 0;
16631   return ret;
16632 }
16633
16634 #ifdef SUPPORT_DISASSEMBLY
16635 /* Needed by the i386 disassembler.  For extra credit, someone could
16636    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16637    symbols.  */
16638
16639 void
16640 print_address (unsigned int addr, FILE * outfile)
16641 {
16642   fprintf (outfile,"0x%8.8x", addr);
16643 }
16644
16645 /* Needed by the i386 disassembler.  */
16646 void
16647 db_task_printsym (unsigned int addr)
16648 {
16649   print_address (addr, stderr);
16650 }
16651 #endif
16652
16653 int
16654 main (int argc, char ** argv)
16655 {
16656   int err;
16657
16658 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16659   setlocale (LC_MESSAGES, "");
16660 #endif
16661 #if defined (HAVE_SETLOCALE)
16662   setlocale (LC_CTYPE, "");
16663 #endif
16664   bindtextdomain (PACKAGE, LOCALEDIR);
16665   textdomain (PACKAGE);
16666
16667   expandargv (&argc, &argv);
16668
16669   parse_args (argc, argv);
16670
16671   if (num_dump_sects > 0)
16672     {
16673       /* Make a copy of the dump_sects array.  */
16674       cmdline_dump_sects = (dump_type *)
16675           malloc (num_dump_sects * sizeof (* dump_sects));
16676       if (cmdline_dump_sects == NULL)
16677         error (_("Out of memory allocating dump request table.\n"));
16678       else
16679         {
16680           memcpy (cmdline_dump_sects, dump_sects,
16681                   num_dump_sects * sizeof (* dump_sects));
16682           num_cmdline_dump_sects = num_dump_sects;
16683         }
16684     }
16685
16686   if (optind < (argc - 1))
16687     show_name = 1;
16688   else if (optind >= argc)
16689     {
16690       warn (_("Nothing to do.\n"));
16691       usage (stderr);
16692     }
16693
16694   err = 0;
16695   while (optind < argc)
16696     err |= process_file (argv[optind++]);
16697
16698   if (dump_sects != NULL)
16699     free (dump_sects);
16700   if (cmdline_dump_sects != NULL)
16701     free (cmdline_dump_sects);
16702
16703   return err;
16704 }