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             default:
2780               strcat (buf, ", unrecognized flag for ARCv2");
2781               break;
2782             }
2783           switch (e_flags & EF_ARC_OSABI_MSK)
2784             {
2785               /* Only upstream 3.9+ kernels will support ARCv2
2786                  ISA.  */
2787             case E_ARC_OSABI_V3:
2788               strcat (buf, ", v3 no-legacy-syscalls ABI");
2789               break;
2790             }
2791           break;
2792
2793         case EM_ARC_COMPACT:
2794           switch (e_flags & EF_ARC_MACH_MSK)
2795             {
2796             case E_ARC_MACH_ARC600:
2797               strcat (buf, ", ARC 600");
2798               break;
2799             case E_ARC_MACH_ARC601:
2800               strcat (buf, ", ARC 601");
2801               break;
2802             case E_ARC_MACH_ARC700:
2803               strcat (buf, ", ARC 700");
2804               break;
2805             default:
2806               strcat (buf, ", Generic ARCompact");
2807               break;
2808             }
2809           switch (e_flags & EF_ARC_OSABI_MSK)
2810             {
2811             case E_ARC_OSABI_ORIG:
2812               strcat (buf, ", legacy syscall ABI");
2813               break;
2814             case E_ARC_OSABI_V2:
2815               /* For 3.2+ Linux kernels which use asm-generic
2816                  hdrs.  */
2817               strcat (buf, ", v2 syscall ABI");
2818               break;
2819             case E_ARC_OSABI_V3:
2820               /* Upstream 3.9+ kernels which don't use any legacy
2821                  syscalls.  */
2822               strcat (buf, ", v3 no-legacy-syscalls ABI");
2823               break;
2824             }
2825           break;
2826
2827         case EM_ARM:
2828           decode_ARM_machine_flags (e_flags, buf);
2829           break;
2830
2831         case EM_AVR:
2832           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2833           break;
2834
2835         case EM_BLACKFIN:
2836           if (e_flags & EF_BFIN_PIC)
2837             strcat (buf, ", PIC");
2838
2839           if (e_flags & EF_BFIN_FDPIC)
2840             strcat (buf, ", FDPIC");
2841
2842           if (e_flags & EF_BFIN_CODE_IN_L1)
2843             strcat (buf, ", code in L1");
2844
2845           if (e_flags & EF_BFIN_DATA_IN_L1)
2846             strcat (buf, ", data in L1");
2847
2848           break;
2849
2850         case EM_CYGNUS_FRV:
2851           switch (e_flags & EF_FRV_CPU_MASK)
2852             {
2853             case EF_FRV_CPU_GENERIC:
2854               break;
2855
2856             default:
2857               strcat (buf, ", fr???");
2858               break;
2859
2860             case EF_FRV_CPU_FR300:
2861               strcat (buf, ", fr300");
2862               break;
2863
2864             case EF_FRV_CPU_FR400:
2865               strcat (buf, ", fr400");
2866               break;
2867             case EF_FRV_CPU_FR405:
2868               strcat (buf, ", fr405");
2869               break;
2870
2871             case EF_FRV_CPU_FR450:
2872               strcat (buf, ", fr450");
2873               break;
2874
2875             case EF_FRV_CPU_FR500:
2876               strcat (buf, ", fr500");
2877               break;
2878             case EF_FRV_CPU_FR550:
2879               strcat (buf, ", fr550");
2880               break;
2881
2882             case EF_FRV_CPU_SIMPLE:
2883               strcat (buf, ", simple");
2884               break;
2885             case EF_FRV_CPU_TOMCAT:
2886               strcat (buf, ", tomcat");
2887               break;
2888             }
2889           break;
2890
2891         case EM_68K:
2892           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2893             strcat (buf, ", m68000");
2894           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2895             strcat (buf, ", cpu32");
2896           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2897             strcat (buf, ", fido_a");
2898           else
2899             {
2900               char const * isa = _("unknown");
2901               char const * mac = _("unknown mac");
2902               char const * additional = NULL;
2903
2904               switch (e_flags & EF_M68K_CF_ISA_MASK)
2905                 {
2906                 case EF_M68K_CF_ISA_A_NODIV:
2907                   isa = "A";
2908                   additional = ", nodiv";
2909                   break;
2910                 case EF_M68K_CF_ISA_A:
2911                   isa = "A";
2912                   break;
2913                 case EF_M68K_CF_ISA_A_PLUS:
2914                   isa = "A+";
2915                   break;
2916                 case EF_M68K_CF_ISA_B_NOUSP:
2917                   isa = "B";
2918                   additional = ", nousp";
2919                   break;
2920                 case EF_M68K_CF_ISA_B:
2921                   isa = "B";
2922                   break;
2923                 case EF_M68K_CF_ISA_C:
2924                   isa = "C";
2925                   break;
2926                 case EF_M68K_CF_ISA_C_NODIV:
2927                   isa = "C";
2928                   additional = ", nodiv";
2929                   break;
2930                 }
2931               strcat (buf, ", cf, isa ");
2932               strcat (buf, isa);
2933               if (additional)
2934                 strcat (buf, additional);
2935               if (e_flags & EF_M68K_CF_FLOAT)
2936                 strcat (buf, ", float");
2937               switch (e_flags & EF_M68K_CF_MAC_MASK)
2938                 {
2939                 case 0:
2940                   mac = NULL;
2941                   break;
2942                 case EF_M68K_CF_MAC:
2943                   mac = "mac";
2944                   break;
2945                 case EF_M68K_CF_EMAC:
2946                   mac = "emac";
2947                   break;
2948                 case EF_M68K_CF_EMAC_B:
2949                   mac = "emac_b";
2950                   break;
2951                 }
2952               if (mac)
2953                 {
2954                   strcat (buf, ", ");
2955                   strcat (buf, mac);
2956                 }
2957             }
2958           break;
2959
2960         case EM_CYGNUS_MEP:
2961           switch (e_flags & EF_MEP_CPU_MASK)
2962             {
2963             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2964             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2965             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2966             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2967             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2968             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2969             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2970             }
2971
2972           switch (e_flags & EF_MEP_COP_MASK)
2973             {
2974             case EF_MEP_COP_NONE: break;
2975             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2976             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2977             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2978             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2979             default: strcat (buf, _("<unknown MeP copro type>")); break;
2980             }
2981
2982           if (e_flags & EF_MEP_LIBRARY)
2983             strcat (buf, ", Built for Library");
2984
2985           if (e_flags & EF_MEP_INDEX_MASK)
2986             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2987                      e_flags & EF_MEP_INDEX_MASK);
2988
2989           if (e_flags & ~ EF_MEP_ALL_FLAGS)
2990             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2991                      e_flags & ~ EF_MEP_ALL_FLAGS);
2992           break;
2993
2994         case EM_PPC:
2995           if (e_flags & EF_PPC_EMB)
2996             strcat (buf, ", emb");
2997
2998           if (e_flags & EF_PPC_RELOCATABLE)
2999             strcat (buf, _(", relocatable"));
3000
3001           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3002             strcat (buf, _(", relocatable-lib"));
3003           break;
3004
3005         case EM_PPC64:
3006           if (e_flags & EF_PPC64_ABI)
3007             {
3008               char abi[] = ", abiv0";
3009
3010               abi[6] += e_flags & EF_PPC64_ABI;
3011               strcat (buf, abi);
3012             }
3013           break;
3014
3015         case EM_V800:
3016           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3017             strcat (buf, ", RH850 ABI");
3018
3019           if (e_flags & EF_V800_850E3)
3020             strcat (buf, ", V3 architecture");
3021
3022           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3023             strcat (buf, ", FPU not used");
3024
3025           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3026             strcat (buf, ", regmode: COMMON");
3027
3028           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3029             strcat (buf, ", r4 not used");
3030
3031           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3032             strcat (buf, ", r30 not used");
3033
3034           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3035             strcat (buf, ", r5 not used");
3036
3037           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3038             strcat (buf, ", r2 not used");
3039
3040           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3041             {
3042               switch (e_flags & - e_flags)
3043                 {
3044                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3045                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3046                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3047                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3048                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3049                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3050                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3051                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3052                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3053                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3054                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3055                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3056                 default: break;
3057                 }
3058             }
3059           break;
3060
3061         case EM_V850:
3062         case EM_CYGNUS_V850:
3063           switch (e_flags & EF_V850_ARCH)
3064             {
3065             case E_V850E3V5_ARCH:
3066               strcat (buf, ", v850e3v5");
3067               break;
3068             case E_V850E2V3_ARCH:
3069               strcat (buf, ", v850e2v3");
3070               break;
3071             case E_V850E2_ARCH:
3072               strcat (buf, ", v850e2");
3073               break;
3074             case E_V850E1_ARCH:
3075               strcat (buf, ", v850e1");
3076               break;
3077             case E_V850E_ARCH:
3078               strcat (buf, ", v850e");
3079               break;
3080             case E_V850_ARCH:
3081               strcat (buf, ", v850");
3082               break;
3083             default:
3084               strcat (buf, _(", unknown v850 architecture variant"));
3085               break;
3086             }
3087           break;
3088
3089         case EM_M32R:
3090         case EM_CYGNUS_M32R:
3091           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3092             strcat (buf, ", m32r");
3093           break;
3094
3095         case EM_MIPS:
3096         case EM_MIPS_RS3_LE:
3097           if (e_flags & EF_MIPS_NOREORDER)
3098             strcat (buf, ", noreorder");
3099
3100           if (e_flags & EF_MIPS_PIC)
3101             strcat (buf, ", pic");
3102
3103           if (e_flags & EF_MIPS_CPIC)
3104             strcat (buf, ", cpic");
3105
3106           if (e_flags & EF_MIPS_UCODE)
3107             strcat (buf, ", ugen_reserved");
3108
3109           if (e_flags & EF_MIPS_ABI2)
3110             strcat (buf, ", abi2");
3111
3112           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3113             strcat (buf, ", odk first");
3114
3115           if (e_flags & EF_MIPS_32BITMODE)
3116             strcat (buf, ", 32bitmode");
3117
3118           if (e_flags & EF_MIPS_NAN2008)
3119             strcat (buf, ", nan2008");
3120
3121           if (e_flags & EF_MIPS_FP64)
3122             strcat (buf, ", fp64");
3123
3124           switch ((e_flags & EF_MIPS_MACH))
3125             {
3126             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3127             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3128             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3129             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3130             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3131             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3132             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3133             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3134             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3135             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3136             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3137             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3138             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3139             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3140             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3141             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3142             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3143             case 0:
3144             /* We simply ignore the field in this case to avoid confusion:
3145                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3146                extension.  */
3147               break;
3148             default: strcat (buf, _(", unknown CPU")); break;
3149             }
3150
3151           switch ((e_flags & EF_MIPS_ABI))
3152             {
3153             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3154             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3155             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3156             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3157             case 0:
3158             /* We simply ignore the field in this case to avoid confusion:
3159                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3160                This means it is likely to be an o32 file, but not for
3161                sure.  */
3162               break;
3163             default: strcat (buf, _(", unknown ABI")); break;
3164             }
3165
3166           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3167             strcat (buf, ", mdmx");
3168
3169           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3170             strcat (buf, ", mips16");
3171
3172           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3173             strcat (buf, ", micromips");
3174
3175           switch ((e_flags & EF_MIPS_ARCH))
3176             {
3177             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3178             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3179             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3180             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3181             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3182             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3183             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3184             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3185             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3186             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3187             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3188             default: strcat (buf, _(", unknown ISA")); break;
3189             }
3190           break;
3191
3192         case EM_NDS32:
3193           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3194           break;
3195
3196         case EM_SH:
3197           switch ((e_flags & EF_SH_MACH_MASK))
3198             {
3199             case EF_SH1: strcat (buf, ", sh1"); break;
3200             case EF_SH2: strcat (buf, ", sh2"); break;
3201             case EF_SH3: strcat (buf, ", sh3"); break;
3202             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3203             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3204             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3205             case EF_SH3E: strcat (buf, ", sh3e"); break;
3206             case EF_SH4: strcat (buf, ", sh4"); break;
3207             case EF_SH5: strcat (buf, ", sh5"); break;
3208             case EF_SH2E: strcat (buf, ", sh2e"); break;
3209             case EF_SH4A: strcat (buf, ", sh4a"); break;
3210             case EF_SH2A: strcat (buf, ", sh2a"); break;
3211             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3212             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3213             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3214             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3215             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3216             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3217             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3218             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3219             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3220             default: strcat (buf, _(", unknown ISA")); break;
3221             }
3222
3223           if (e_flags & EF_SH_PIC)
3224             strcat (buf, ", pic");
3225
3226           if (e_flags & EF_SH_FDPIC)
3227             strcat (buf, ", fdpic");
3228           break;
3229
3230         case EM_OR1K:
3231           if (e_flags & EF_OR1K_NODELAY)
3232             strcat (buf, ", no delay");
3233           break;
3234
3235         case EM_SPARCV9:
3236           if (e_flags & EF_SPARC_32PLUS)
3237             strcat (buf, ", v8+");
3238
3239           if (e_flags & EF_SPARC_SUN_US1)
3240             strcat (buf, ", ultrasparcI");
3241
3242           if (e_flags & EF_SPARC_SUN_US3)
3243             strcat (buf, ", ultrasparcIII");
3244
3245           if (e_flags & EF_SPARC_HAL_R1)
3246             strcat (buf, ", halr1");
3247
3248           if (e_flags & EF_SPARC_LEDATA)
3249             strcat (buf, ", ledata");
3250
3251           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3252             strcat (buf, ", tso");
3253
3254           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3255             strcat (buf, ", pso");
3256
3257           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3258             strcat (buf, ", rmo");
3259           break;
3260
3261         case EM_PARISC:
3262           switch (e_flags & EF_PARISC_ARCH)
3263             {
3264             case EFA_PARISC_1_0:
3265               strcpy (buf, ", PA-RISC 1.0");
3266               break;
3267             case EFA_PARISC_1_1:
3268               strcpy (buf, ", PA-RISC 1.1");
3269               break;
3270             case EFA_PARISC_2_0:
3271               strcpy (buf, ", PA-RISC 2.0");
3272               break;
3273             default:
3274               break;
3275             }
3276           if (e_flags & EF_PARISC_TRAPNIL)
3277             strcat (buf, ", trapnil");
3278           if (e_flags & EF_PARISC_EXT)
3279             strcat (buf, ", ext");
3280           if (e_flags & EF_PARISC_LSB)
3281             strcat (buf, ", lsb");
3282           if (e_flags & EF_PARISC_WIDE)
3283             strcat (buf, ", wide");
3284           if (e_flags & EF_PARISC_NO_KABP)
3285             strcat (buf, ", no kabp");
3286           if (e_flags & EF_PARISC_LAZYSWAP)
3287             strcat (buf, ", lazyswap");
3288           break;
3289
3290         case EM_PJ:
3291         case EM_PJ_OLD:
3292           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3293             strcat (buf, ", new calling convention");
3294
3295           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3296             strcat (buf, ", gnu calling convention");
3297           break;
3298
3299         case EM_IA_64:
3300           if ((e_flags & EF_IA_64_ABI64))
3301             strcat (buf, ", 64-bit");
3302           else
3303             strcat (buf, ", 32-bit");
3304           if ((e_flags & EF_IA_64_REDUCEDFP))
3305             strcat (buf, ", reduced fp model");
3306           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3307             strcat (buf, ", no function descriptors, constant gp");
3308           else if ((e_flags & EF_IA_64_CONS_GP))
3309             strcat (buf, ", constant gp");
3310           if ((e_flags & EF_IA_64_ABSOLUTE))
3311             strcat (buf, ", absolute");
3312           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3313             {
3314               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3315                 strcat (buf, ", vms_linkages");
3316               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3317                 {
3318                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3319                   break;
3320                 case EF_IA_64_VMS_COMCOD_WARNING:
3321                   strcat (buf, ", warning");
3322                   break;
3323                 case EF_IA_64_VMS_COMCOD_ERROR:
3324                   strcat (buf, ", error");
3325                   break;
3326                 case EF_IA_64_VMS_COMCOD_ABORT:
3327                   strcat (buf, ", abort");
3328                   break;
3329                 default:
3330                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3331                         e_flags & EF_IA_64_VMS_COMCOD);
3332                   strcat (buf, ", <unknown>");
3333                 }
3334             }
3335           break;
3336
3337         case EM_VAX:
3338           if ((e_flags & EF_VAX_NONPIC))
3339             strcat (buf, ", non-PIC");
3340           if ((e_flags & EF_VAX_DFLOAT))
3341             strcat (buf, ", D-Float");
3342           if ((e_flags & EF_VAX_GFLOAT))
3343             strcat (buf, ", G-Float");
3344           break;
3345
3346         case EM_VISIUM:
3347           if (e_flags & EF_VISIUM_ARCH_MCM)
3348             strcat (buf, ", mcm");
3349           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3350             strcat (buf, ", mcm24");
3351           if (e_flags & EF_VISIUM_ARCH_GR6)
3352             strcat (buf, ", gr6");
3353           break;
3354
3355         case EM_RL78:
3356           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3357             {
3358             case E_FLAG_RL78_ANY_CPU: break;
3359             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3360             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3361             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3362             }
3363           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3364             strcat (buf, ", 64-bit doubles");
3365           break;
3366
3367         case EM_RX:
3368           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3369             strcat (buf, ", 64-bit doubles");
3370           if (e_flags & E_FLAG_RX_DSP)
3371             strcat (buf, ", dsp");
3372           if (e_flags & E_FLAG_RX_PID)
3373             strcat (buf, ", pid");
3374           if (e_flags & E_FLAG_RX_ABI)
3375             strcat (buf, ", RX ABI");
3376           if (e_flags & E_FLAG_RX_SINSNS_SET)
3377             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3378                     ? ", uses String instructions" : ", bans String instructions");
3379           if (e_flags & E_FLAG_RX_V2)
3380             strcat (buf, ", V2");
3381           break;
3382
3383         case EM_S390:
3384           if (e_flags & EF_S390_HIGH_GPRS)
3385             strcat (buf, ", highgprs");
3386           break;
3387
3388         case EM_TI_C6000:
3389           if ((e_flags & EF_C6000_REL))
3390             strcat (buf, ", relocatable module");
3391           break;
3392
3393         case EM_MSP430:
3394           strcat (buf, _(": architecture variant: "));
3395           switch (e_flags & EF_MSP430_MACH)
3396             {
3397             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3398             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3399             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3400             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3401             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3402             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3403             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3404             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3405             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3406             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3407             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3408             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3409             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3410             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3411             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3412             default:
3413               strcat (buf, _(": unknown")); break;
3414             }
3415
3416           if (e_flags & ~ EF_MSP430_MACH)
3417             strcat (buf, _(": unknown extra flag bits also present"));
3418         }
3419     }
3420
3421   return buf;
3422 }
3423
3424 static const char *
3425 get_osabi_name (unsigned int osabi)
3426 {
3427   static char buff[32];
3428
3429   switch (osabi)
3430     {
3431     case ELFOSABI_NONE:         return "UNIX - System V";
3432     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3433     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3434     case ELFOSABI_GNU:          return "UNIX - GNU";
3435     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3436     case ELFOSABI_AIX:          return "UNIX - AIX";
3437     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3438     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3439     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3440     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3441     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3442     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3443     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3444     case ELFOSABI_AROS:         return "AROS";
3445     case ELFOSABI_FENIXOS:      return "FenixOS";
3446     default:
3447       if (osabi >= 64)
3448         switch (elf_header.e_machine)
3449           {
3450           case EM_ARM:
3451             switch (osabi)
3452               {
3453               case ELFOSABI_ARM:        return "ARM";
3454               default:
3455                 break;
3456               }
3457             break;
3458
3459           case EM_MSP430:
3460           case EM_MSP430_OLD:
3461           case EM_VISIUM:
3462             switch (osabi)
3463               {
3464               case ELFOSABI_STANDALONE: return _("Standalone App");
3465               default:
3466                 break;
3467               }
3468             break;
3469
3470           case EM_TI_C6000:
3471             switch (osabi)
3472               {
3473               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3474               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3475               default:
3476                 break;
3477               }
3478             break;
3479
3480           default:
3481             break;
3482           }
3483       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3484       return buff;
3485     }
3486 }
3487
3488 static const char *
3489 get_aarch64_segment_type (unsigned long type)
3490 {
3491   switch (type)
3492     {
3493     case PT_AARCH64_ARCHEXT:
3494       return "AARCH64_ARCHEXT";
3495     default:
3496       break;
3497     }
3498
3499   return NULL;
3500 }
3501
3502 static const char *
3503 get_arm_segment_type (unsigned long type)
3504 {
3505   switch (type)
3506     {
3507     case PT_ARM_EXIDX:
3508       return "EXIDX";
3509     default:
3510       break;
3511     }
3512
3513   return NULL;
3514 }
3515
3516 static const char *
3517 get_mips_segment_type (unsigned long type)
3518 {
3519   switch (type)
3520     {
3521     case PT_MIPS_REGINFO:
3522       return "REGINFO";
3523     case PT_MIPS_RTPROC:
3524       return "RTPROC";
3525     case PT_MIPS_OPTIONS:
3526       return "OPTIONS";
3527     case PT_MIPS_ABIFLAGS:
3528       return "ABIFLAGS";
3529     default:
3530       break;
3531     }
3532
3533   return NULL;
3534 }
3535
3536 static const char *
3537 get_parisc_segment_type (unsigned long type)
3538 {
3539   switch (type)
3540     {
3541     case PT_HP_TLS:             return "HP_TLS";
3542     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3543     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3544     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3545     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3546     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3547     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3548     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3549     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3550     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3551     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3552     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3553     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3554     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3555     case PT_HP_STACK:           return "HP_STACK";
3556     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3557     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3558     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3559     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3560     default:
3561       break;
3562     }
3563
3564   return NULL;
3565 }
3566
3567 static const char *
3568 get_ia64_segment_type (unsigned long type)
3569 {
3570   switch (type)
3571     {
3572     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3573     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3574     case PT_HP_TLS:             return "HP_TLS";
3575     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3576     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3577     case PT_IA_64_HP_STACK:     return "HP_STACK";
3578     default:
3579       break;
3580     }
3581
3582   return NULL;
3583 }
3584
3585 static const char *
3586 get_tic6x_segment_type (unsigned long type)
3587 {
3588   switch (type)
3589     {
3590     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3591     default:
3592       break;
3593     }
3594
3595   return NULL;
3596 }
3597
3598 static const char *
3599 get_segment_type (unsigned long p_type)
3600 {
3601   static char buff[32];
3602
3603   switch (p_type)
3604     {
3605     case PT_NULL:       return "NULL";
3606     case PT_LOAD:       return "LOAD";
3607     case PT_DYNAMIC:    return "DYNAMIC";
3608     case PT_INTERP:     return "INTERP";
3609     case PT_NOTE:       return "NOTE";
3610     case PT_SHLIB:      return "SHLIB";
3611     case PT_PHDR:       return "PHDR";
3612     case PT_TLS:        return "TLS";
3613
3614     case PT_GNU_EH_FRAME:
3615                         return "GNU_EH_FRAME";
3616     case PT_GNU_STACK:  return "GNU_STACK";
3617     case PT_GNU_RELRO:  return "GNU_RELRO";
3618
3619     default:
3620       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3621         {
3622           const char * result;
3623
3624           switch (elf_header.e_machine)
3625             {
3626             case EM_AARCH64:
3627               result = get_aarch64_segment_type (p_type);
3628               break;
3629             case EM_ARM:
3630               result = get_arm_segment_type (p_type);
3631               break;
3632             case EM_MIPS:
3633             case EM_MIPS_RS3_LE:
3634               result = get_mips_segment_type (p_type);
3635               break;
3636             case EM_PARISC:
3637               result = get_parisc_segment_type (p_type);
3638               break;
3639             case EM_IA_64:
3640               result = get_ia64_segment_type (p_type);
3641               break;
3642             case EM_TI_C6000:
3643               result = get_tic6x_segment_type (p_type);
3644               break;
3645             default:
3646               result = NULL;
3647               break;
3648             }
3649
3650           if (result != NULL)
3651             return result;
3652
3653           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3654         }
3655       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3656         {
3657           const char * result;
3658
3659           switch (elf_header.e_machine)
3660             {
3661             case EM_PARISC:
3662               result = get_parisc_segment_type (p_type);
3663               break;
3664             case EM_IA_64:
3665               result = get_ia64_segment_type (p_type);
3666               break;
3667             default:
3668               result = NULL;
3669               break;
3670             }
3671
3672           if (result != NULL)
3673             return result;
3674
3675           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3676         }
3677       else
3678         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3679
3680       return buff;
3681     }
3682 }
3683
3684 static const char *
3685 get_mips_section_type_name (unsigned int sh_type)
3686 {
3687   switch (sh_type)
3688     {
3689     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3690     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3691     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3692     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3693     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3694     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3695     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3696     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3697     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3698     case SHT_MIPS_RELD:          return "MIPS_RELD";
3699     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3700     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3701     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3702     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3703     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3704     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3705     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3706     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3707     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3708     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3709     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3710     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3711     case SHT_MIPS_LINE:          return "MIPS_LINE";
3712     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3713     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3714     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3715     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3716     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3717     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3718     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3719     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3720     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3721     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3722     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3723     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3724     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3725     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3726     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3727     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3728     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3729     default:
3730       break;
3731     }
3732   return NULL;
3733 }
3734
3735 static const char *
3736 get_parisc_section_type_name (unsigned int sh_type)
3737 {
3738   switch (sh_type)
3739     {
3740     case SHT_PARISC_EXT:        return "PARISC_EXT";
3741     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3742     case SHT_PARISC_DOC:        return "PARISC_DOC";
3743     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3744     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3745     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3746     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3747     default:
3748       break;
3749     }
3750   return NULL;
3751 }
3752
3753 static const char *
3754 get_ia64_section_type_name (unsigned int sh_type)
3755 {
3756   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3757   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3758     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3759
3760   switch (sh_type)
3761     {
3762     case SHT_IA_64_EXT:                return "IA_64_EXT";
3763     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3764     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3765     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3766     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3767     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3768     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3769     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3770     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3771     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3772     default:
3773       break;
3774     }
3775   return NULL;
3776 }
3777
3778 static const char *
3779 get_x86_64_section_type_name (unsigned int sh_type)
3780 {
3781   switch (sh_type)
3782     {
3783     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3784     default:
3785       break;
3786     }
3787   return NULL;
3788 }
3789
3790 static const char *
3791 get_aarch64_section_type_name (unsigned int sh_type)
3792 {
3793   switch (sh_type)
3794     {
3795     case SHT_AARCH64_ATTRIBUTES:
3796       return "AARCH64_ATTRIBUTES";
3797     default:
3798       break;
3799     }
3800   return NULL;
3801 }
3802
3803 static const char *
3804 get_arm_section_type_name (unsigned int sh_type)
3805 {
3806   switch (sh_type)
3807     {
3808     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3809     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3810     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3811     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3812     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3813     default:
3814       break;
3815     }
3816   return NULL;
3817 }
3818
3819 static const char *
3820 get_tic6x_section_type_name (unsigned int sh_type)
3821 {
3822   switch (sh_type)
3823     {
3824     case SHT_C6000_UNWIND:
3825       return "C6000_UNWIND";
3826     case SHT_C6000_PREEMPTMAP:
3827       return "C6000_PREEMPTMAP";
3828     case SHT_C6000_ATTRIBUTES:
3829       return "C6000_ATTRIBUTES";
3830     case SHT_TI_ICODE:
3831       return "TI_ICODE";
3832     case SHT_TI_XREF:
3833       return "TI_XREF";
3834     case SHT_TI_HANDLER:
3835       return "TI_HANDLER";
3836     case SHT_TI_INITINFO:
3837       return "TI_INITINFO";
3838     case SHT_TI_PHATTRS:
3839       return "TI_PHATTRS";
3840     default:
3841       break;
3842     }
3843   return NULL;
3844 }
3845
3846 static const char *
3847 get_msp430x_section_type_name (unsigned int sh_type)
3848 {
3849   switch (sh_type)
3850     {
3851     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3852     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3853     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3854     default: return NULL;
3855     }
3856 }
3857
3858 static const char *
3859 get_v850_section_type_name (unsigned int sh_type)
3860 {
3861   switch (sh_type)
3862     {
3863     case SHT_V850_SCOMMON: return "V850 Small Common";
3864     case SHT_V850_TCOMMON: return "V850 Tiny Common";
3865     case SHT_V850_ZCOMMON: return "V850 Zero Common";
3866     case SHT_RENESAS_IOP:  return "RENESAS IOP";
3867     case SHT_RENESAS_INFO: return "RENESAS INFO";
3868     default: return NULL;
3869     }
3870 }
3871
3872 static const char *
3873 get_section_type_name (unsigned int sh_type)
3874 {
3875   static char buff[32];
3876
3877   switch (sh_type)
3878     {
3879     case SHT_NULL:              return "NULL";
3880     case SHT_PROGBITS:          return "PROGBITS";
3881     case SHT_SYMTAB:            return "SYMTAB";
3882     case SHT_STRTAB:            return "STRTAB";
3883     case SHT_RELA:              return "RELA";
3884     case SHT_HASH:              return "HASH";
3885     case SHT_DYNAMIC:           return "DYNAMIC";
3886     case SHT_NOTE:              return "NOTE";
3887     case SHT_NOBITS:            return "NOBITS";
3888     case SHT_REL:               return "REL";
3889     case SHT_SHLIB:             return "SHLIB";
3890     case SHT_DYNSYM:            return "DYNSYM";
3891     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3892     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3893     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3894     case SHT_GNU_HASH:          return "GNU_HASH";
3895     case SHT_GROUP:             return "GROUP";
3896     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3897     case SHT_GNU_verdef:        return "VERDEF";
3898     case SHT_GNU_verneed:       return "VERNEED";
3899     case SHT_GNU_versym:        return "VERSYM";
3900     case 0x6ffffff0:            return "VERSYM";
3901     case 0x6ffffffc:            return "VERDEF";
3902     case 0x7ffffffd:            return "AUXILIARY";
3903     case 0x7fffffff:            return "FILTER";
3904     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3905
3906     default:
3907       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3908         {
3909           const char * result;
3910
3911           switch (elf_header.e_machine)
3912             {
3913             case EM_MIPS:
3914             case EM_MIPS_RS3_LE:
3915               result = get_mips_section_type_name (sh_type);
3916               break;
3917             case EM_PARISC:
3918               result = get_parisc_section_type_name (sh_type);
3919               break;
3920             case EM_IA_64:
3921               result = get_ia64_section_type_name (sh_type);
3922               break;
3923             case EM_X86_64:
3924             case EM_L1OM:
3925             case EM_K1OM:
3926               result = get_x86_64_section_type_name (sh_type);
3927               break;
3928             case EM_AARCH64:
3929               result = get_aarch64_section_type_name (sh_type);
3930               break;
3931             case EM_ARM:
3932               result = get_arm_section_type_name (sh_type);
3933               break;
3934             case EM_TI_C6000:
3935               result = get_tic6x_section_type_name (sh_type);
3936               break;
3937             case EM_MSP430:
3938               result = get_msp430x_section_type_name (sh_type);
3939               break;
3940             case EM_V800:
3941             case EM_V850:
3942             case EM_CYGNUS_V850:
3943               result = get_v850_section_type_name (sh_type);
3944               break;
3945             default:
3946               result = NULL;
3947               break;
3948             }
3949
3950           if (result != NULL)
3951             return result;
3952
3953           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3954         }
3955       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3956         {
3957           const char * result;
3958
3959           switch (elf_header.e_machine)
3960             {
3961             case EM_IA_64:
3962               result = get_ia64_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, "LOOS+%x", sh_type - SHT_LOOS);
3973         }
3974       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3975         {
3976           switch (elf_header.e_machine)
3977             {
3978             case EM_V800:
3979             case EM_V850:
3980             case EM_CYGNUS_V850:
3981               return get_v850_section_type_name (sh_type);
3982             default:
3983               break;
3984             }
3985
3986           sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3987         }
3988       else
3989         /* This message is probably going to be displayed in a 15
3990            character wide field, so put the hex value first.  */
3991         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3992
3993       return buff;
3994     }
3995 }
3996
3997 #define OPTION_DEBUG_DUMP       512
3998 #define OPTION_DYN_SYMS         513
3999 #define OPTION_DWARF_DEPTH      514
4000 #define OPTION_DWARF_START      515
4001 #define OPTION_DWARF_CHECK      516
4002
4003 static struct option options[] =
4004 {
4005   {"all",              no_argument, 0, 'a'},
4006   {"file-header",      no_argument, 0, 'h'},
4007   {"program-headers",  no_argument, 0, 'l'},
4008   {"headers",          no_argument, 0, 'e'},
4009   {"histogram",        no_argument, 0, 'I'},
4010   {"segments",         no_argument, 0, 'l'},
4011   {"sections",         no_argument, 0, 'S'},
4012   {"section-headers",  no_argument, 0, 'S'},
4013   {"section-groups",   no_argument, 0, 'g'},
4014   {"section-details",  no_argument, 0, 't'},
4015   {"full-section-name",no_argument, 0, 'N'},
4016   {"symbols",          no_argument, 0, 's'},
4017   {"syms",             no_argument, 0, 's'},
4018   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4019   {"relocs",           no_argument, 0, 'r'},
4020   {"notes",            no_argument, 0, 'n'},
4021   {"dynamic",          no_argument, 0, 'd'},
4022   {"arch-specific",    no_argument, 0, 'A'},
4023   {"version-info",     no_argument, 0, 'V'},
4024   {"use-dynamic",      no_argument, 0, 'D'},
4025   {"unwind",           no_argument, 0, 'u'},
4026   {"archive-index",    no_argument, 0, 'c'},
4027   {"hex-dump",         required_argument, 0, 'x'},
4028   {"relocated-dump",   required_argument, 0, 'R'},
4029   {"string-dump",      required_argument, 0, 'p'},
4030   {"decompress",       no_argument, 0, 'z'},
4031 #ifdef SUPPORT_DISASSEMBLY
4032   {"instruction-dump", required_argument, 0, 'i'},
4033 #endif
4034   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4035
4036   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4037   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4038   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4039
4040   {"version",          no_argument, 0, 'v'},
4041   {"wide",             no_argument, 0, 'W'},
4042   {"help",             no_argument, 0, 'H'},
4043   {0,                  no_argument, 0, 0}
4044 };
4045
4046 static void
4047 usage (FILE * stream)
4048 {
4049   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4050   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4051   fprintf (stream, _(" Options are:\n\
4052   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4053   -h --file-header       Display the ELF file header\n\
4054   -l --program-headers   Display the program headers\n\
4055      --segments          An alias for --program-headers\n\
4056   -S --section-headers   Display the sections' header\n\
4057      --sections          An alias for --section-headers\n\
4058   -g --section-groups    Display the section groups\n\
4059   -t --section-details   Display the section details\n\
4060   -e --headers           Equivalent to: -h -l -S\n\
4061   -s --syms              Display the symbol table\n\
4062      --symbols           An alias for --syms\n\
4063   --dyn-syms             Display the dynamic symbol table\n\
4064   -n --notes             Display the core notes (if present)\n\
4065   -r --relocs            Display the relocations (if present)\n\
4066   -u --unwind            Display the unwind info (if present)\n\
4067   -d --dynamic           Display the dynamic section (if present)\n\
4068   -V --version-info      Display the version sections (if present)\n\
4069   -A --arch-specific     Display architecture specific information (if any)\n\
4070   -c --archive-index     Display the symbol/file index in an archive\n\
4071   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4072   -x --hex-dump=<number|name>\n\
4073                          Dump the contents of section <number|name> as bytes\n\
4074   -p --string-dump=<number|name>\n\
4075                          Dump the contents of section <number|name> as strings\n\
4076   -R --relocated-dump=<number|name>\n\
4077                          Dump the contents of section <number|name> as relocated bytes\n\
4078   -z --decompress        Decompress section before dumping it\n\
4079   -w[lLiaprmfFsoRt] or\n\
4080   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4081                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4082                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4083                =addr,=cu_index]\n\
4084                          Display the contents of DWARF2 debug sections\n"));
4085   fprintf (stream, _("\
4086   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4087   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4088                          or deeper\n"));
4089 #ifdef SUPPORT_DISASSEMBLY
4090   fprintf (stream, _("\
4091   -i --instruction-dump=<number|name>\n\
4092                          Disassemble the contents of section <number|name>\n"));
4093 #endif
4094   fprintf (stream, _("\
4095   -I --histogram         Display histogram of bucket list lengths\n\
4096   -W --wide              Allow output width to exceed 80 characters\n\
4097   @<file>                Read options from <file>\n\
4098   -H --help              Display this information\n\
4099   -v --version           Display the version number of readelf\n"));
4100
4101   if (REPORT_BUGS_TO[0] && stream == stdout)
4102     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4103
4104   exit (stream == stdout ? 0 : 1);
4105 }
4106
4107 /* Record the fact that the user wants the contents of section number
4108    SECTION to be displayed using the method(s) encoded as flags bits
4109    in TYPE.  Note, TYPE can be zero if we are creating the array for
4110    the first time.  */
4111
4112 static void
4113 request_dump_bynumber (unsigned int section, dump_type type)
4114 {
4115   if (section >= num_dump_sects)
4116     {
4117       dump_type * new_dump_sects;
4118
4119       new_dump_sects = (dump_type *) calloc (section + 1,
4120                                              sizeof (* dump_sects));
4121
4122       if (new_dump_sects == NULL)
4123         error (_("Out of memory allocating dump request table.\n"));
4124       else
4125         {
4126           /* Copy current flag settings.  */
4127           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4128
4129           free (dump_sects);
4130
4131           dump_sects = new_dump_sects;
4132           num_dump_sects = section + 1;
4133         }
4134     }
4135
4136   if (dump_sects)
4137     dump_sects[section] |= type;
4138
4139   return;
4140 }
4141
4142 /* Request a dump by section name.  */
4143
4144 static void
4145 request_dump_byname (const char * section, dump_type type)
4146 {
4147   struct dump_list_entry * new_request;
4148
4149   new_request = (struct dump_list_entry *)
4150       malloc (sizeof (struct dump_list_entry));
4151   if (!new_request)
4152     error (_("Out of memory allocating dump request table.\n"));
4153
4154   new_request->name = strdup (section);
4155   if (!new_request->name)
4156     error (_("Out of memory allocating dump request table.\n"));
4157
4158   new_request->type = type;
4159
4160   new_request->next = dump_sects_byname;
4161   dump_sects_byname = new_request;
4162 }
4163
4164 static inline void
4165 request_dump (dump_type type)
4166 {
4167   int section;
4168   char * cp;
4169
4170   do_dump++;
4171   section = strtoul (optarg, & cp, 0);
4172
4173   if (! *cp && section >= 0)
4174     request_dump_bynumber (section, type);
4175   else
4176     request_dump_byname (optarg, type);
4177 }
4178
4179
4180 static void
4181 parse_args (int argc, char ** argv)
4182 {
4183   int c;
4184
4185   if (argc < 2)
4186     usage (stderr);
4187
4188   while ((c = getopt_long
4189           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4190     {
4191       switch (c)
4192         {
4193         case 0:
4194           /* Long options.  */
4195           break;
4196         case 'H':
4197           usage (stdout);
4198           break;
4199
4200         case 'a':
4201           do_syms++;
4202           do_reloc++;
4203           do_unwind++;
4204           do_dynamic++;
4205           do_header++;
4206           do_sections++;
4207           do_section_groups++;
4208           do_segments++;
4209           do_version++;
4210           do_histogram++;
4211           do_arch++;
4212           do_notes++;
4213           break;
4214         case 'g':
4215           do_section_groups++;
4216           break;
4217         case 't':
4218         case 'N':
4219           do_sections++;
4220           do_section_details++;
4221           break;
4222         case 'e':
4223           do_header++;
4224           do_sections++;
4225           do_segments++;
4226           break;
4227         case 'A':
4228           do_arch++;
4229           break;
4230         case 'D':
4231           do_using_dynamic++;
4232           break;
4233         case 'r':
4234           do_reloc++;
4235           break;
4236         case 'u':
4237           do_unwind++;
4238           break;
4239         case 'h':
4240           do_header++;
4241           break;
4242         case 'l':
4243           do_segments++;
4244           break;
4245         case 's':
4246           do_syms++;
4247           break;
4248         case 'S':
4249           do_sections++;
4250           break;
4251         case 'd':
4252           do_dynamic++;
4253           break;
4254         case 'I':
4255           do_histogram++;
4256           break;
4257         case 'n':
4258           do_notes++;
4259           break;
4260         case 'c':
4261           do_archive_index++;
4262           break;
4263         case 'x':
4264           request_dump (HEX_DUMP);
4265           break;
4266         case 'p':
4267           request_dump (STRING_DUMP);
4268           break;
4269         case 'R':
4270           request_dump (RELOC_DUMP);
4271           break;
4272         case 'z':
4273           decompress_dumps++;
4274           break;
4275         case 'w':
4276           do_dump++;
4277           if (optarg == 0)
4278             {
4279               do_debugging = 1;
4280               dwarf_select_sections_all ();
4281             }
4282           else
4283             {
4284               do_debugging = 0;
4285               dwarf_select_sections_by_letters (optarg);
4286             }
4287           break;
4288         case OPTION_DEBUG_DUMP:
4289           do_dump++;
4290           if (optarg == 0)
4291             do_debugging = 1;
4292           else
4293             {
4294               do_debugging = 0;
4295               dwarf_select_sections_by_names (optarg);
4296             }
4297           break;
4298         case OPTION_DWARF_DEPTH:
4299           {
4300             char *cp;
4301
4302             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4303           }
4304           break;
4305         case OPTION_DWARF_START:
4306           {
4307             char *cp;
4308
4309             dwarf_start_die = strtoul (optarg, & cp, 0);
4310           }
4311           break;
4312         case OPTION_DWARF_CHECK:
4313           dwarf_check = 1;
4314           break;
4315         case OPTION_DYN_SYMS:
4316           do_dyn_syms++;
4317           break;
4318 #ifdef SUPPORT_DISASSEMBLY
4319         case 'i':
4320           request_dump (DISASS_DUMP);
4321           break;
4322 #endif
4323         case 'v':
4324           print_version (program_name);
4325           break;
4326         case 'V':
4327           do_version++;
4328           break;
4329         case 'W':
4330           do_wide++;
4331           break;
4332         default:
4333           /* xgettext:c-format */
4334           error (_("Invalid option '-%c'\n"), c);
4335           /* Drop through.  */
4336         case '?':
4337           usage (stderr);
4338         }
4339     }
4340
4341   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4342       && !do_segments && !do_header && !do_dump && !do_version
4343       && !do_histogram && !do_debugging && !do_arch && !do_notes
4344       && !do_section_groups && !do_archive_index
4345       && !do_dyn_syms)
4346     usage (stderr);
4347 }
4348
4349 static const char *
4350 get_elf_class (unsigned int elf_class)
4351 {
4352   static char buff[32];
4353
4354   switch (elf_class)
4355     {
4356     case ELFCLASSNONE: return _("none");
4357     case ELFCLASS32:   return "ELF32";
4358     case ELFCLASS64:   return "ELF64";
4359     default:
4360       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4361       return buff;
4362     }
4363 }
4364
4365 static const char *
4366 get_data_encoding (unsigned int encoding)
4367 {
4368   static char buff[32];
4369
4370   switch (encoding)
4371     {
4372     case ELFDATANONE: return _("none");
4373     case ELFDATA2LSB: return _("2's complement, little endian");
4374     case ELFDATA2MSB: return _("2's complement, big endian");
4375     default:
4376       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4377       return buff;
4378     }
4379 }
4380
4381 /* Decode the data held in 'elf_header'.  */
4382
4383 static int
4384 process_file_header (void)
4385 {
4386   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4387       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4388       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4389       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4390     {
4391       error
4392         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4393       return 0;
4394     }
4395
4396   init_dwarf_regnames (elf_header.e_machine);
4397
4398   if (do_header)
4399     {
4400       int i;
4401
4402       printf (_("ELF Header:\n"));
4403       printf (_("  Magic:   "));
4404       for (i = 0; i < EI_NIDENT; i++)
4405         printf ("%2.2x ", elf_header.e_ident[i]);
4406       printf ("\n");
4407       printf (_("  Class:                             %s\n"),
4408               get_elf_class (elf_header.e_ident[EI_CLASS]));
4409       printf (_("  Data:                              %s\n"),
4410               get_data_encoding (elf_header.e_ident[EI_DATA]));
4411       printf (_("  Version:                           %d %s\n"),
4412               elf_header.e_ident[EI_VERSION],
4413               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4414                ? "(current)"
4415                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4416                   ? _("<unknown: %lx>")
4417                   : "")));
4418       printf (_("  OS/ABI:                            %s\n"),
4419               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4420       printf (_("  ABI Version:                       %d\n"),
4421               elf_header.e_ident[EI_ABIVERSION]);
4422       printf (_("  Type:                              %s\n"),
4423               get_file_type (elf_header.e_type));
4424       printf (_("  Machine:                           %s\n"),
4425               get_machine_name (elf_header.e_machine));
4426       printf (_("  Version:                           0x%lx\n"),
4427               (unsigned long) elf_header.e_version);
4428
4429       printf (_("  Entry point address:               "));
4430       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4431       printf (_("\n  Start of program headers:          "));
4432       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4433       printf (_(" (bytes into file)\n  Start of section headers:          "));
4434       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4435       printf (_(" (bytes into file)\n"));
4436
4437       printf (_("  Flags:                             0x%lx%s\n"),
4438               (unsigned long) elf_header.e_flags,
4439               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4440       printf (_("  Size of this header:               %ld (bytes)\n"),
4441               (long) elf_header.e_ehsize);
4442       printf (_("  Size of program headers:           %ld (bytes)\n"),
4443               (long) elf_header.e_phentsize);
4444       printf (_("  Number of program headers:         %ld"),
4445               (long) elf_header.e_phnum);
4446       if (section_headers != NULL
4447           && elf_header.e_phnum == PN_XNUM
4448           && section_headers[0].sh_info != 0)
4449         printf (" (%ld)", (long) section_headers[0].sh_info);
4450       putc ('\n', stdout);
4451       printf (_("  Size of section headers:           %ld (bytes)\n"),
4452               (long) elf_header.e_shentsize);
4453       printf (_("  Number of section headers:         %ld"),
4454               (long) elf_header.e_shnum);
4455       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4456         printf (" (%ld)", (long) section_headers[0].sh_size);
4457       putc ('\n', stdout);
4458       printf (_("  Section header string table index: %ld"),
4459               (long) elf_header.e_shstrndx);
4460       if (section_headers != NULL
4461           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4462         printf (" (%u)", section_headers[0].sh_link);
4463       else if (elf_header.e_shstrndx != SHN_UNDEF
4464                && elf_header.e_shstrndx >= elf_header.e_shnum)
4465         printf (_(" <corrupt: out of range>"));
4466       putc ('\n', stdout);
4467     }
4468
4469   if (section_headers != NULL)
4470     {
4471       if (elf_header.e_phnum == PN_XNUM
4472           && section_headers[0].sh_info != 0)
4473         elf_header.e_phnum = section_headers[0].sh_info;
4474       if (elf_header.e_shnum == SHN_UNDEF)
4475         elf_header.e_shnum = section_headers[0].sh_size;
4476       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4477         elf_header.e_shstrndx = section_headers[0].sh_link;
4478       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4479         elf_header.e_shstrndx = SHN_UNDEF;
4480       free (section_headers);
4481       section_headers = NULL;
4482     }
4483
4484   return 1;
4485 }
4486
4487 static bfd_boolean
4488 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4489 {
4490   Elf32_External_Phdr * phdrs;
4491   Elf32_External_Phdr * external;
4492   Elf_Internal_Phdr *   internal;
4493   unsigned int i;
4494   unsigned int size = elf_header.e_phentsize;
4495   unsigned int num  = elf_header.e_phnum;
4496
4497   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4498   if (size == 0 || num == 0)
4499     return FALSE;
4500   if (size < sizeof * phdrs)
4501     {
4502       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4503       return FALSE;
4504     }
4505   if (size > sizeof * phdrs)
4506     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4507
4508   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4509                                             size, num, _("program headers"));
4510   if (phdrs == NULL)
4511     return FALSE;
4512
4513   for (i = 0, internal = pheaders, external = phdrs;
4514        i < elf_header.e_phnum;
4515        i++, internal++, external++)
4516     {
4517       internal->p_type   = BYTE_GET (external->p_type);
4518       internal->p_offset = BYTE_GET (external->p_offset);
4519       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4520       internal->p_paddr  = BYTE_GET (external->p_paddr);
4521       internal->p_filesz = BYTE_GET (external->p_filesz);
4522       internal->p_memsz  = BYTE_GET (external->p_memsz);
4523       internal->p_flags  = BYTE_GET (external->p_flags);
4524       internal->p_align  = BYTE_GET (external->p_align);
4525     }
4526
4527   free (phdrs);
4528   return TRUE;
4529 }
4530
4531 static bfd_boolean
4532 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4533 {
4534   Elf64_External_Phdr * phdrs;
4535   Elf64_External_Phdr * external;
4536   Elf_Internal_Phdr *   internal;
4537   unsigned int i;
4538   unsigned int size = elf_header.e_phentsize;
4539   unsigned int num  = elf_header.e_phnum;
4540
4541   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4542   if (size == 0 || num == 0)
4543     return FALSE;
4544   if (size < sizeof * phdrs)
4545     {
4546       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4547       return FALSE;
4548     }
4549   if (size > sizeof * phdrs)
4550     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4551
4552   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4553                                             size, num, _("program headers"));
4554   if (!phdrs)
4555     return FALSE;
4556
4557   for (i = 0, internal = pheaders, external = phdrs;
4558        i < elf_header.e_phnum;
4559        i++, internal++, external++)
4560     {
4561       internal->p_type   = BYTE_GET (external->p_type);
4562       internal->p_flags  = BYTE_GET (external->p_flags);
4563       internal->p_offset = BYTE_GET (external->p_offset);
4564       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4565       internal->p_paddr  = BYTE_GET (external->p_paddr);
4566       internal->p_filesz = BYTE_GET (external->p_filesz);
4567       internal->p_memsz  = BYTE_GET (external->p_memsz);
4568       internal->p_align  = BYTE_GET (external->p_align);
4569     }
4570
4571   free (phdrs);
4572   return TRUE;
4573 }
4574
4575 /* Returns 1 if the program headers were read into `program_headers'.  */
4576
4577 static int
4578 get_program_headers (FILE * file)
4579 {
4580   Elf_Internal_Phdr * phdrs;
4581
4582   /* Check cache of prior read.  */
4583   if (program_headers != NULL)
4584     return 1;
4585
4586   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4587                                          sizeof (Elf_Internal_Phdr));
4588
4589   if (phdrs == NULL)
4590     {
4591       error (_("Out of memory reading %u program headers\n"),
4592              elf_header.e_phnum);
4593       return 0;
4594     }
4595
4596   if (is_32bit_elf
4597       ? get_32bit_program_headers (file, phdrs)
4598       : get_64bit_program_headers (file, phdrs))
4599     {
4600       program_headers = phdrs;
4601       return 1;
4602     }
4603
4604   free (phdrs);
4605   return 0;
4606 }
4607
4608 /* Returns 1 if the program headers were loaded.  */
4609
4610 static int
4611 process_program_headers (FILE * file)
4612 {
4613   Elf_Internal_Phdr * segment;
4614   unsigned int i;
4615
4616   if (elf_header.e_phnum == 0)
4617     {
4618       /* PR binutils/12467.  */
4619       if (elf_header.e_phoff != 0)
4620         warn (_("possibly corrupt ELF header - it has a non-zero program"
4621                 " header offset, but no program headers\n"));
4622       else if (do_segments)
4623         printf (_("\nThere are no program headers in this file.\n"));
4624       return 0;
4625     }
4626
4627   if (do_segments && !do_header)
4628     {
4629       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4630       printf (_("Entry point "));
4631       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4632       printf (_("\nThere are %d program headers, starting at offset "),
4633               elf_header.e_phnum);
4634       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4635       printf ("\n");
4636     }
4637
4638   if (! get_program_headers (file))
4639       return 0;
4640
4641   if (do_segments)
4642     {
4643       if (elf_header.e_phnum > 1)
4644         printf (_("\nProgram Headers:\n"));
4645       else
4646         printf (_("\nProgram Headers:\n"));
4647
4648       if (is_32bit_elf)
4649         printf
4650           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4651       else if (do_wide)
4652         printf
4653           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4654       else
4655         {
4656           printf
4657             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4658           printf
4659             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4660         }
4661     }
4662
4663   dynamic_addr = 0;
4664   dynamic_size = 0;
4665
4666   for (i = 0, segment = program_headers;
4667        i < elf_header.e_phnum;
4668        i++, segment++)
4669     {
4670       if (do_segments)
4671         {
4672           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4673
4674           if (is_32bit_elf)
4675             {
4676               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4677               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4678               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4679               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4680               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4681               printf ("%c%c%c ",
4682                       (segment->p_flags & PF_R ? 'R' : ' '),
4683                       (segment->p_flags & PF_W ? 'W' : ' '),
4684                       (segment->p_flags & PF_X ? 'E' : ' '));
4685               printf ("%#lx", (unsigned long) segment->p_align);
4686             }
4687           else if (do_wide)
4688             {
4689               if ((unsigned long) segment->p_offset == segment->p_offset)
4690                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4691               else
4692                 {
4693                   print_vma (segment->p_offset, FULL_HEX);
4694                   putchar (' ');
4695                 }
4696
4697               print_vma (segment->p_vaddr, FULL_HEX);
4698               putchar (' ');
4699               print_vma (segment->p_paddr, FULL_HEX);
4700               putchar (' ');
4701
4702               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4703                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4704               else
4705                 {
4706                   print_vma (segment->p_filesz, FULL_HEX);
4707                   putchar (' ');
4708                 }
4709
4710               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4711                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4712               else
4713                 {
4714                   print_vma (segment->p_memsz, FULL_HEX);
4715                 }
4716
4717               printf (" %c%c%c ",
4718                       (segment->p_flags & PF_R ? 'R' : ' '),
4719                       (segment->p_flags & PF_W ? 'W' : ' '),
4720                       (segment->p_flags & PF_X ? 'E' : ' '));
4721
4722               if ((unsigned long) segment->p_align == segment->p_align)
4723                 printf ("%#lx", (unsigned long) segment->p_align);
4724               else
4725                 {
4726                   print_vma (segment->p_align, PREFIX_HEX);
4727                 }
4728             }
4729           else
4730             {
4731               print_vma (segment->p_offset, FULL_HEX);
4732               putchar (' ');
4733               print_vma (segment->p_vaddr, FULL_HEX);
4734               putchar (' ');
4735               print_vma (segment->p_paddr, FULL_HEX);
4736               printf ("\n                 ");
4737               print_vma (segment->p_filesz, FULL_HEX);
4738               putchar (' ');
4739               print_vma (segment->p_memsz, FULL_HEX);
4740               printf ("  %c%c%c    ",
4741                       (segment->p_flags & PF_R ? 'R' : ' '),
4742                       (segment->p_flags & PF_W ? 'W' : ' '),
4743                       (segment->p_flags & PF_X ? 'E' : ' '));
4744               print_vma (segment->p_align, HEX);
4745             }
4746         }
4747
4748       if (do_segments)
4749         putc ('\n', stdout);
4750
4751       switch (segment->p_type)
4752         {
4753         case PT_DYNAMIC:
4754           if (dynamic_addr)
4755             error (_("more than one dynamic segment\n"));
4756
4757           /* By default, assume that the .dynamic section is the first
4758              section in the DYNAMIC segment.  */
4759           dynamic_addr = segment->p_offset;
4760           dynamic_size = segment->p_filesz;
4761           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4762           if (dynamic_addr + dynamic_size >= current_file_size)
4763             {
4764               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4765               dynamic_addr = dynamic_size = 0;
4766             }
4767
4768           /* Try to locate the .dynamic section. If there is
4769              a section header table, we can easily locate it.  */
4770           if (section_headers != NULL)
4771             {
4772               Elf_Internal_Shdr * sec;
4773
4774               sec = find_section (".dynamic");
4775               if (sec == NULL || sec->sh_size == 0)
4776                 {
4777                   /* A corresponding .dynamic section is expected, but on
4778                      IA-64/OpenVMS it is OK for it to be missing.  */
4779                   if (!is_ia64_vms ())
4780                     error (_("no .dynamic section in the dynamic segment\n"));
4781                   break;
4782                 }
4783
4784               if (sec->sh_type == SHT_NOBITS)
4785                 {
4786                   dynamic_size = 0;
4787                   break;
4788                 }
4789
4790               dynamic_addr = sec->sh_offset;
4791               dynamic_size = sec->sh_size;
4792
4793               if (dynamic_addr < segment->p_offset
4794                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4795                 warn (_("the .dynamic section is not contained"
4796                         " within the dynamic segment\n"));
4797               else if (dynamic_addr > segment->p_offset)
4798                 warn (_("the .dynamic section is not the first section"
4799                         " in the dynamic segment.\n"));
4800             }
4801           break;
4802
4803         case PT_INTERP:
4804           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4805                      SEEK_SET))
4806             error (_("Unable to find program interpreter name\n"));
4807           else
4808             {
4809               char fmt [32];
4810               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4811
4812               if (ret >= (int) sizeof (fmt) || ret < 0)
4813                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4814
4815               program_interpreter[0] = 0;
4816               if (fscanf (file, fmt, program_interpreter) <= 0)
4817                 error (_("Unable to read program interpreter name\n"));
4818
4819               if (do_segments)
4820                 printf (_("      [Requesting program interpreter: %s]\n"),
4821                     program_interpreter);
4822             }
4823           break;
4824         }
4825     }
4826
4827   if (do_segments && section_headers != NULL && string_table != NULL)
4828     {
4829       printf (_("\n Section to Segment mapping:\n"));
4830       printf (_("  Segment Sections...\n"));
4831
4832       for (i = 0; i < elf_header.e_phnum; i++)
4833         {
4834           unsigned int j;
4835           Elf_Internal_Shdr * section;
4836
4837           segment = program_headers + i;
4838           section = section_headers + 1;
4839
4840           printf ("   %2.2d     ", i);
4841
4842           for (j = 1; j < elf_header.e_shnum; j++, section++)
4843             {
4844               if (!ELF_TBSS_SPECIAL (section, segment)
4845                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4846                 printf ("%s ", printable_section_name (section));
4847             }
4848
4849           putc ('\n',stdout);
4850         }
4851     }
4852
4853   return 1;
4854 }
4855
4856
4857 /* Find the file offset corresponding to VMA by using the program headers.  */
4858
4859 static long
4860 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4861 {
4862   Elf_Internal_Phdr * seg;
4863
4864   if (! get_program_headers (file))
4865     {
4866       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4867       return (long) vma;
4868     }
4869
4870   for (seg = program_headers;
4871        seg < program_headers + elf_header.e_phnum;
4872        ++seg)
4873     {
4874       if (seg->p_type != PT_LOAD)
4875         continue;
4876
4877       if (vma >= (seg->p_vaddr & -seg->p_align)
4878           && vma + size <= seg->p_vaddr + seg->p_filesz)
4879         return vma - seg->p_vaddr + seg->p_offset;
4880     }
4881
4882   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4883         (unsigned long) vma);
4884   return (long) vma;
4885 }
4886
4887
4888 /* Allocate memory and load the sections headers into the global pointer
4889    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4890    generate any error messages if the load fails.  */
4891
4892 static bfd_boolean
4893 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4894 {
4895   Elf32_External_Shdr * shdrs;
4896   Elf_Internal_Shdr *   internal;
4897   unsigned int i;
4898   unsigned int size = elf_header.e_shentsize;
4899   unsigned int num = probe ? 1 : elf_header.e_shnum;
4900
4901   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4902   if (size == 0 || num == 0)
4903     return FALSE;
4904   if (size < sizeof * shdrs)
4905     {
4906       if (! probe)
4907         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4908       return FALSE;
4909     }
4910   if (!probe && size > sizeof * shdrs)
4911     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4912
4913   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4914                                             size, num,
4915                                             probe ? NULL : _("section headers"));
4916   if (shdrs == NULL)
4917     return FALSE;
4918
4919   if (section_headers != NULL)
4920     free (section_headers);
4921   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4922                                                    sizeof (Elf_Internal_Shdr));
4923   if (section_headers == NULL)
4924     {
4925       if (!probe)
4926         error (_("Out of memory reading %u section headers\n"), num);
4927       return FALSE;
4928     }
4929
4930   for (i = 0, internal = section_headers;
4931        i < num;
4932        i++, internal++)
4933     {
4934       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4935       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4936       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4937       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4938       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4939       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4940       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4941       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4942       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4943       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4944     }
4945
4946   free (shdrs);
4947   return TRUE;
4948 }
4949
4950 static bfd_boolean
4951 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4952 {
4953   Elf64_External_Shdr * shdrs;
4954   Elf_Internal_Shdr *   internal;
4955   unsigned int i;
4956   unsigned int size = elf_header.e_shentsize;
4957   unsigned int num = probe ? 1 : elf_header.e_shnum;
4958
4959   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4960   if (size == 0 || num == 0)
4961     return FALSE;
4962   if (size < sizeof * shdrs)
4963     {
4964       if (! probe)
4965         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4966       return FALSE;
4967     }
4968   if (! probe && size > sizeof * shdrs)
4969     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4970
4971   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4972                                             size, num,
4973                                             probe ? NULL : _("section headers"));
4974   if (shdrs == NULL)
4975     return FALSE;
4976
4977   if (section_headers != NULL)
4978     free (section_headers);
4979   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4980                                                    sizeof (Elf_Internal_Shdr));
4981   if (section_headers == NULL)
4982     {
4983       if (! probe)
4984         error (_("Out of memory reading %u section headers\n"), num);
4985       return FALSE;
4986     }
4987
4988   for (i = 0, internal = section_headers;
4989        i < num;
4990        i++, internal++)
4991     {
4992       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4993       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4994       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4995       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4996       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4997       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4998       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4999       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5000       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5001       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5002     }
5003
5004   free (shdrs);
5005   return TRUE;
5006 }
5007
5008 static Elf_Internal_Sym *
5009 get_32bit_elf_symbols (FILE * file,
5010                        Elf_Internal_Shdr * section,
5011                        unsigned long * num_syms_return)
5012 {
5013   unsigned long number = 0;
5014   Elf32_External_Sym * esyms = NULL;
5015   Elf_External_Sym_Shndx * shndx = NULL;
5016   Elf_Internal_Sym * isyms = NULL;
5017   Elf_Internal_Sym * psym;
5018   unsigned int j;
5019
5020   if (section->sh_size == 0)
5021     {
5022       if (num_syms_return != NULL)
5023         * num_syms_return = 0;
5024       return NULL;
5025     }
5026
5027   /* Run some sanity checks first.  */
5028   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5029     {
5030       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5031              printable_section_name (section), (unsigned long) section->sh_entsize);
5032       goto exit_point;
5033     }
5034
5035   if (section->sh_size > current_file_size)
5036     {
5037       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5038              printable_section_name (section), (unsigned long) section->sh_size);
5039       goto exit_point;
5040     }
5041
5042   number = section->sh_size / section->sh_entsize;
5043
5044   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5045     {
5046       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5047              (unsigned long) section->sh_size,
5048              printable_section_name (section),
5049              (unsigned long) section->sh_entsize);
5050       goto exit_point;
5051     }
5052
5053   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5054                                            section->sh_size, _("symbols"));
5055   if (esyms == NULL)
5056     goto exit_point;
5057
5058   {
5059     elf_section_list * entry;
5060
5061     shndx = NULL;
5062     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5063       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5064         {
5065           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5066                                                        entry->hdr->sh_offset,
5067                                                        1, entry->hdr->sh_size,
5068                                                        _("symbol table section indicies"));
5069           if (shndx == NULL)
5070             goto exit_point;
5071           /* PR17531: file: heap-buffer-overflow */
5072           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5073             {
5074               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5075                      printable_section_name (entry->hdr),
5076                      (unsigned long) entry->hdr->sh_size,
5077                      (unsigned long) section->sh_size);
5078               goto exit_point;
5079             }
5080         }
5081   }
5082
5083   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5084
5085   if (isyms == NULL)
5086     {
5087       error (_("Out of memory reading %lu symbols\n"),
5088              (unsigned long) number);
5089       goto exit_point;
5090     }
5091
5092   for (j = 0, psym = isyms; j < number; j++, psym++)
5093     {
5094       psym->st_name  = BYTE_GET (esyms[j].st_name);
5095       psym->st_value = BYTE_GET (esyms[j].st_value);
5096       psym->st_size  = BYTE_GET (esyms[j].st_size);
5097       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5098       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5099         psym->st_shndx
5100           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5101       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5102         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5103       psym->st_info  = BYTE_GET (esyms[j].st_info);
5104       psym->st_other = BYTE_GET (esyms[j].st_other);
5105     }
5106
5107  exit_point:
5108   if (shndx != NULL)
5109     free (shndx);
5110   if (esyms != NULL)
5111     free (esyms);
5112
5113   if (num_syms_return != NULL)
5114     * num_syms_return = isyms == NULL ? 0 : number;
5115
5116   return isyms;
5117 }
5118
5119 static Elf_Internal_Sym *
5120 get_64bit_elf_symbols (FILE * file,
5121                        Elf_Internal_Shdr * section,
5122                        unsigned long * num_syms_return)
5123 {
5124   unsigned long number = 0;
5125   Elf64_External_Sym * esyms = NULL;
5126   Elf_External_Sym_Shndx * shndx = NULL;
5127   Elf_Internal_Sym * isyms = NULL;
5128   Elf_Internal_Sym * psym;
5129   unsigned int j;
5130
5131   if (section->sh_size == 0)
5132     {
5133       if (num_syms_return != NULL)
5134         * num_syms_return = 0;
5135       return NULL;
5136     }
5137
5138   /* Run some sanity checks first.  */
5139   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5140     {
5141       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5142              printable_section_name (section),
5143              (unsigned long) section->sh_entsize);
5144       goto exit_point;
5145     }
5146
5147   if (section->sh_size > current_file_size)
5148     {
5149       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5150              printable_section_name (section),
5151              (unsigned long) section->sh_size);
5152       goto exit_point;
5153     }
5154
5155   number = section->sh_size / section->sh_entsize;
5156
5157   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5158     {
5159       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5160              (unsigned long) section->sh_size,
5161              printable_section_name (section),
5162              (unsigned long) section->sh_entsize);
5163       goto exit_point;
5164     }
5165
5166   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5167                                            section->sh_size, _("symbols"));
5168   if (!esyms)
5169     goto exit_point;
5170
5171   {
5172     elf_section_list * entry;
5173
5174     shndx = NULL;
5175     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5176       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5177         {
5178           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5179                                                        entry->hdr->sh_offset,
5180                                                        1, entry->hdr->sh_size,
5181                                                        _("symbol table section indicies"));
5182           if (shndx == NULL)
5183             goto exit_point;
5184           /* PR17531: file: heap-buffer-overflow */
5185           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5186             {
5187               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5188                      printable_section_name (entry->hdr),
5189                      (unsigned long) entry->hdr->sh_size,
5190                      (unsigned long) section->sh_size);
5191               goto exit_point;
5192             }
5193         }
5194   }
5195
5196   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5197
5198   if (isyms == NULL)
5199     {
5200       error (_("Out of memory reading %lu symbols\n"),
5201              (unsigned long) number);
5202       goto exit_point;
5203     }
5204
5205   for (j = 0, psym = isyms; j < number; j++, psym++)
5206     {
5207       psym->st_name  = BYTE_GET (esyms[j].st_name);
5208       psym->st_info  = BYTE_GET (esyms[j].st_info);
5209       psym->st_other = BYTE_GET (esyms[j].st_other);
5210       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5211
5212       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5213         psym->st_shndx
5214           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5215       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5216         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5217
5218       psym->st_value = BYTE_GET (esyms[j].st_value);
5219       psym->st_size  = BYTE_GET (esyms[j].st_size);
5220     }
5221
5222  exit_point:
5223   if (shndx != NULL)
5224     free (shndx);
5225   if (esyms != NULL)
5226     free (esyms);
5227
5228   if (num_syms_return != NULL)
5229     * num_syms_return = isyms == NULL ? 0 : number;
5230
5231   return isyms;
5232 }
5233
5234 static const char *
5235 get_elf_section_flags (bfd_vma sh_flags)
5236 {
5237   static char buff[1024];
5238   char * p = buff;
5239   int field_size = is_32bit_elf ? 8 : 16;
5240   int sindex;
5241   int size = sizeof (buff) - (field_size + 4 + 1);
5242   bfd_vma os_flags = 0;
5243   bfd_vma proc_flags = 0;
5244   bfd_vma unknown_flags = 0;
5245   static const struct
5246     {
5247       const char * str;
5248       int len;
5249     }
5250   flags [] =
5251     {
5252       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5253       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5254       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5255       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5256       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5257       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5258       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5259       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5260       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5261       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5262       /* IA-64 specific.  */
5263       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5264       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5265       /* IA-64 OpenVMS specific.  */
5266       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5267       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5268       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5269       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5270       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5271       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5272       /* Generic.  */
5273       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5274       /* SPARC specific.  */
5275       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5276       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5277       /* ARM specific.  */
5278       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5279       /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5280       /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5281     };
5282
5283   if (do_section_details)
5284     {
5285       sprintf (buff, "[%*.*lx]: ",
5286                field_size, field_size, (unsigned long) sh_flags);
5287       p += field_size + 4;
5288     }
5289
5290   while (sh_flags)
5291     {
5292       bfd_vma flag;
5293
5294       flag = sh_flags & - sh_flags;
5295       sh_flags &= ~ flag;
5296
5297       if (do_section_details)
5298         {
5299           switch (flag)
5300             {
5301             case SHF_WRITE:             sindex = 0; break;
5302             case SHF_ALLOC:             sindex = 1; break;
5303             case SHF_EXECINSTR:         sindex = 2; break;
5304             case SHF_MERGE:             sindex = 3; break;
5305             case SHF_STRINGS:           sindex = 4; break;
5306             case SHF_INFO_LINK:         sindex = 5; break;
5307             case SHF_LINK_ORDER:        sindex = 6; break;
5308             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5309             case SHF_GROUP:             sindex = 8; break;
5310             case SHF_TLS:               sindex = 9; break;
5311             case SHF_EXCLUDE:           sindex = 18; break;
5312             case SHF_COMPRESSED:        sindex = 20; break;
5313
5314             default:
5315               sindex = -1;
5316               switch (elf_header.e_machine)
5317                 {
5318                 case EM_IA_64:
5319                   if (flag == SHF_IA_64_SHORT)
5320                     sindex = 10;
5321                   else if (flag == SHF_IA_64_NORECOV)
5322                     sindex = 11;
5323 #ifdef BFD64
5324                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5325                     switch (flag)
5326                       {
5327                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5328                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5329                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5330                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5331                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5332                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5333                       default:                        break;
5334                       }
5335 #endif
5336                   break;
5337
5338                 case EM_386:
5339                 case EM_IAMCU:
5340                 case EM_X86_64:
5341                 case EM_L1OM:
5342                 case EM_K1OM:
5343                 case EM_OLD_SPARCV9:
5344                 case EM_SPARC32PLUS:
5345                 case EM_SPARCV9:
5346                 case EM_SPARC:
5347                   if (flag == SHF_ORDERED)
5348                     sindex = 19;
5349                   break;
5350
5351                 case EM_ARM:
5352                   switch (flag)
5353                     {
5354                     case SHF_ENTRYSECT: sindex = 21; break;
5355                     case SHF_ARM_NOREAD: sindex = 22; break;
5356                     case SHF_COMDEF: sindex = 23; break;
5357                     default: break;
5358                     }
5359                   break;
5360
5361                 default:
5362                   break;
5363                 }
5364             }
5365
5366           if (sindex != -1)
5367             {
5368               if (p != buff + field_size + 4)
5369                 {
5370                   if (size < (10 + 2))
5371                     {
5372                       warn (_("Internal error: not enough buffer room for section flag info"));
5373                       return _("<unknown>");
5374                     }
5375                   size -= 2;
5376                   *p++ = ',';
5377                   *p++ = ' ';
5378                 }
5379
5380               size -= flags [sindex].len;
5381               p = stpcpy (p, flags [sindex].str);
5382             }
5383           else if (flag & SHF_MASKOS)
5384             os_flags |= flag;
5385           else if (flag & SHF_MASKPROC)
5386             proc_flags |= flag;
5387           else
5388             unknown_flags |= flag;
5389         }
5390       else
5391         {
5392           switch (flag)
5393             {
5394             case SHF_WRITE:             *p = 'W'; break;
5395             case SHF_ALLOC:             *p = 'A'; break;
5396             case SHF_EXECINSTR:         *p = 'X'; break;
5397             case SHF_MERGE:             *p = 'M'; break;
5398             case SHF_STRINGS:           *p = 'S'; break;
5399             case SHF_INFO_LINK:         *p = 'I'; break;
5400             case SHF_LINK_ORDER:        *p = 'L'; break;
5401             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5402             case SHF_GROUP:             *p = 'G'; break;
5403             case SHF_TLS:               *p = 'T'; break;
5404             case SHF_EXCLUDE:           *p = 'E'; break;
5405             case SHF_COMPRESSED:        *p = 'C'; break;
5406
5407             default:
5408               if ((elf_header.e_machine == EM_X86_64
5409                    || elf_header.e_machine == EM_L1OM
5410                    || elf_header.e_machine == EM_K1OM)
5411                   && flag == SHF_X86_64_LARGE)
5412                 *p = 'l';
5413               else if (flag & SHF_MASKOS)
5414                 {
5415                   *p = 'o';
5416                   sh_flags &= ~ SHF_MASKOS;
5417                 }
5418               else if (flag & SHF_MASKPROC)
5419                 {
5420                   *p = 'p';
5421                   sh_flags &= ~ SHF_MASKPROC;
5422                 }
5423               else
5424                 *p = 'x';
5425               break;
5426             }
5427           p++;
5428         }
5429     }
5430
5431   if (do_section_details)
5432     {
5433       if (os_flags)
5434         {
5435           size -= 5 + field_size;
5436           if (p != buff + field_size + 4)
5437             {
5438               if (size < (2 + 1))
5439                 {
5440                   warn (_("Internal error: not enough buffer room for section flag info"));
5441                   return _("<unknown>");
5442                 }
5443               size -= 2;
5444               *p++ = ',';
5445               *p++ = ' ';
5446             }
5447           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5448                    (unsigned long) os_flags);
5449           p += 5 + field_size;
5450         }
5451       if (proc_flags)
5452         {
5453           size -= 7 + field_size;
5454           if (p != buff + field_size + 4)
5455             {
5456               if (size < (2 + 1))
5457                 {
5458                   warn (_("Internal error: not enough buffer room for section flag info"));
5459                   return _("<unknown>");
5460                 }
5461               size -= 2;
5462               *p++ = ',';
5463               *p++ = ' ';
5464             }
5465           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5466                    (unsigned long) proc_flags);
5467           p += 7 + field_size;
5468         }
5469       if (unknown_flags)
5470         {
5471           size -= 10 + field_size;
5472           if (p != buff + field_size + 4)
5473             {
5474               if (size < (2 + 1))
5475                 {
5476                   warn (_("Internal error: not enough buffer room for section flag info"));
5477                   return _("<unknown>");
5478                 }
5479               size -= 2;
5480               *p++ = ',';
5481               *p++ = ' ';
5482             }
5483           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5484                    (unsigned long) unknown_flags);
5485           p += 10 + field_size;
5486         }
5487     }
5488
5489   *p = '\0';
5490   return buff;
5491 }
5492
5493 static unsigned int
5494 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5495 {
5496   if (is_32bit_elf)
5497     {
5498       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5499       chdr->ch_type = BYTE_GET (echdr->ch_type);
5500       chdr->ch_size = BYTE_GET (echdr->ch_size);
5501       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5502       return sizeof (*echdr);
5503     }
5504   else
5505     {
5506       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5507       chdr->ch_type = BYTE_GET (echdr->ch_type);
5508       chdr->ch_size = BYTE_GET (echdr->ch_size);
5509       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5510       return sizeof (*echdr);
5511     }
5512 }
5513
5514 static int
5515 process_section_headers (FILE * file)
5516 {
5517   Elf_Internal_Shdr * section;
5518   unsigned int i;
5519
5520   section_headers = NULL;
5521
5522   if (elf_header.e_shnum == 0)
5523     {
5524       /* PR binutils/12467.  */
5525       if (elf_header.e_shoff != 0)
5526         warn (_("possibly corrupt ELF file header - it has a non-zero"
5527                 " section header offset, but no section headers\n"));
5528       else if (do_sections)
5529         printf (_("\nThere are no sections in this file.\n"));
5530
5531       return 1;
5532     }
5533
5534   if (do_sections && !do_header)
5535     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5536             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5537
5538   if (is_32bit_elf)
5539     {
5540       if (! get_32bit_section_headers (file, FALSE))
5541         return 0;
5542     }
5543   else if (! get_64bit_section_headers (file, FALSE))
5544     return 0;
5545
5546   /* Read in the string table, so that we have names to display.  */
5547   if (elf_header.e_shstrndx != SHN_UNDEF
5548        && elf_header.e_shstrndx < elf_header.e_shnum)
5549     {
5550       section = section_headers + elf_header.e_shstrndx;
5551
5552       if (section->sh_size != 0)
5553         {
5554           string_table = (char *) get_data (NULL, file, section->sh_offset,
5555                                             1, section->sh_size,
5556                                             _("string table"));
5557
5558           string_table_length = string_table != NULL ? section->sh_size : 0;
5559         }
5560     }
5561
5562   /* Scan the sections for the dynamic symbol table
5563      and dynamic string table and debug sections.  */
5564   dynamic_symbols = NULL;
5565   dynamic_strings = NULL;
5566   dynamic_syminfo = NULL;
5567   symtab_shndx_list = NULL;
5568
5569   eh_addr_size = is_32bit_elf ? 4 : 8;
5570   switch (elf_header.e_machine)
5571     {
5572     case EM_MIPS:
5573     case EM_MIPS_RS3_LE:
5574       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5575          FDE addresses.  However, the ABI also has a semi-official ILP32
5576          variant for which the normal FDE address size rules apply.
5577
5578          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5579          section, where XX is the size of longs in bits.  Unfortunately,
5580          earlier compilers provided no way of distinguishing ILP32 objects
5581          from LP64 objects, so if there's any doubt, we should assume that
5582          the official LP64 form is being used.  */
5583       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5584           && find_section (".gcc_compiled_long32") == NULL)
5585         eh_addr_size = 8;
5586       break;
5587
5588     case EM_H8_300:
5589     case EM_H8_300H:
5590       switch (elf_header.e_flags & EF_H8_MACH)
5591         {
5592         case E_H8_MACH_H8300:
5593         case E_H8_MACH_H8300HN:
5594         case E_H8_MACH_H8300SN:
5595         case E_H8_MACH_H8300SXN:
5596           eh_addr_size = 2;
5597           break;
5598         case E_H8_MACH_H8300H:
5599         case E_H8_MACH_H8300S:
5600         case E_H8_MACH_H8300SX:
5601           eh_addr_size = 4;
5602           break;
5603         }
5604       break;
5605
5606     case EM_M32C_OLD:
5607     case EM_M32C:
5608       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5609         {
5610         case EF_M32C_CPU_M16C:
5611           eh_addr_size = 2;
5612           break;
5613         }
5614       break;
5615     }
5616
5617 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5618   do                                                                    \
5619     {                                                                   \
5620       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5621       if (section->sh_entsize != expected_entsize)                      \
5622         {                                                               \
5623           char buf[40];                                                 \
5624           sprintf_vma (buf, section->sh_entsize);                       \
5625           /* Note: coded this way so that there is a single string for  \
5626              translation.  */ \
5627           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5628           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5629                    (unsigned) expected_entsize);                        \
5630           section->sh_entsize = expected_entsize;                       \
5631         }                                                               \
5632     }                                                                   \
5633   while (0)
5634
5635 #define CHECK_ENTSIZE(section, i, type)                                 \
5636   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5637                         sizeof (Elf64_External_##type))
5638
5639   for (i = 0, section = section_headers;
5640        i < elf_header.e_shnum;
5641        i++, section++)
5642     {
5643       char * name = SECTION_NAME (section);
5644
5645       if (section->sh_type == SHT_DYNSYM)
5646         {
5647           if (dynamic_symbols != NULL)
5648             {
5649               error (_("File contains multiple dynamic symbol tables\n"));
5650               continue;
5651             }
5652
5653           CHECK_ENTSIZE (section, i, Sym);
5654           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5655         }
5656       else if (section->sh_type == SHT_STRTAB
5657                && streq (name, ".dynstr"))
5658         {
5659           if (dynamic_strings != NULL)
5660             {
5661               error (_("File contains multiple dynamic string tables\n"));
5662               continue;
5663             }
5664
5665           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5666                                                1, section->sh_size,
5667                                                _("dynamic strings"));
5668           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5669         }
5670       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5671         {
5672           elf_section_list * entry = xmalloc (sizeof * entry);
5673           entry->hdr = section;
5674           entry->next = symtab_shndx_list;
5675           symtab_shndx_list = entry;
5676         }
5677       else if (section->sh_type == SHT_SYMTAB)
5678         CHECK_ENTSIZE (section, i, Sym);
5679       else if (section->sh_type == SHT_GROUP)
5680         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5681       else if (section->sh_type == SHT_REL)
5682         CHECK_ENTSIZE (section, i, Rel);
5683       else if (section->sh_type == SHT_RELA)
5684         CHECK_ENTSIZE (section, i, Rela);
5685       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5686                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5687                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5688                 || do_debug_str || do_debug_loc || do_debug_ranges
5689                 || do_debug_addr || do_debug_cu_index)
5690                && (const_strneq (name, ".debug_")
5691                    || const_strneq (name, ".zdebug_")))
5692         {
5693           if (name[1] == 'z')
5694             name += sizeof (".zdebug_") - 1;
5695           else
5696             name += sizeof (".debug_") - 1;
5697
5698           if (do_debugging
5699               || (do_debug_info     && const_strneq (name, "info"))
5700               || (do_debug_info     && const_strneq (name, "types"))
5701               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5702               || (do_debug_lines    && strcmp (name, "line") == 0)
5703               || (do_debug_lines    && const_strneq (name, "line."))
5704               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5705               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5706               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5707               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5708               || (do_debug_aranges  && const_strneq (name, "aranges"))
5709               || (do_debug_ranges   && const_strneq (name, "ranges"))
5710               || (do_debug_frames   && const_strneq (name, "frame"))
5711               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5712               || (do_debug_macinfo  && const_strneq (name, "macro"))
5713               || (do_debug_str      && const_strneq (name, "str"))
5714               || (do_debug_loc      && const_strneq (name, "loc"))
5715               || (do_debug_addr     && const_strneq (name, "addr"))
5716               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5717               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5718               )
5719             request_dump_bynumber (i, DEBUG_DUMP);
5720         }
5721       /* Linkonce section to be combined with .debug_info at link time.  */
5722       else if ((do_debugging || do_debug_info)
5723                && const_strneq (name, ".gnu.linkonce.wi."))
5724         request_dump_bynumber (i, DEBUG_DUMP);
5725       else if (do_debug_frames && streq (name, ".eh_frame"))
5726         request_dump_bynumber (i, DEBUG_DUMP);
5727       else if (do_gdb_index && streq (name, ".gdb_index"))
5728         request_dump_bynumber (i, DEBUG_DUMP);
5729       /* Trace sections for Itanium VMS.  */
5730       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5731                 || do_trace_aranges)
5732                && const_strneq (name, ".trace_"))
5733         {
5734           name += sizeof (".trace_") - 1;
5735
5736           if (do_debugging
5737               || (do_trace_info     && streq (name, "info"))
5738               || (do_trace_abbrevs  && streq (name, "abbrev"))
5739               || (do_trace_aranges  && streq (name, "aranges"))
5740               )
5741             request_dump_bynumber (i, DEBUG_DUMP);
5742         }
5743     }
5744
5745   if (! do_sections)
5746     return 1;
5747
5748   if (elf_header.e_shnum > 1)
5749     printf (_("\nSection Headers:\n"));
5750   else
5751     printf (_("\nSection Header:\n"));
5752
5753   if (is_32bit_elf)
5754     {
5755       if (do_section_details)
5756         {
5757           printf (_("  [Nr] Name\n"));
5758           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5759         }
5760       else
5761         printf
5762           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5763     }
5764   else if (do_wide)
5765     {
5766       if (do_section_details)
5767         {
5768           printf (_("  [Nr] Name\n"));
5769           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5770         }
5771       else
5772         printf
5773           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5774     }
5775   else
5776     {
5777       if (do_section_details)
5778         {
5779           printf (_("  [Nr] Name\n"));
5780           printf (_("       Type              Address          Offset            Link\n"));
5781           printf (_("       Size              EntSize          Info              Align\n"));
5782         }
5783       else
5784         {
5785           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5786           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5787         }
5788     }
5789
5790   if (do_section_details)
5791     printf (_("       Flags\n"));
5792
5793   for (i = 0, section = section_headers;
5794        i < elf_header.e_shnum;
5795        i++, section++)
5796     {
5797       printf ("  [%2u] ", i);
5798       if (do_section_details)
5799         printf ("%s\n      ", printable_section_name (section));
5800       else
5801         print_symbol (-17, SECTION_NAME (section));
5802
5803       printf (do_wide ? " %-15s " : " %-15.15s ",
5804               get_section_type_name (section->sh_type));
5805
5806       if (is_32bit_elf)
5807         {
5808           const char * link_too_big = NULL;
5809
5810           print_vma (section->sh_addr, LONG_HEX);
5811
5812           printf ( " %6.6lx %6.6lx %2.2lx",
5813                    (unsigned long) section->sh_offset,
5814                    (unsigned long) section->sh_size,
5815                    (unsigned long) section->sh_entsize);
5816
5817           if (do_section_details)
5818             fputs ("  ", stdout);
5819           else
5820             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5821
5822           if (section->sh_link >= elf_header.e_shnum)
5823             {
5824               link_too_big = "";
5825               /* The sh_link value is out of range.  Normally this indicates
5826                  an error but it can have special values in Solaris binaries.  */
5827               switch (elf_header.e_machine)
5828                 {
5829                 case EM_386:
5830                 case EM_IAMCU:
5831                 case EM_X86_64:
5832                 case EM_L1OM:
5833                 case EM_K1OM:
5834                 case EM_OLD_SPARCV9:
5835                 case EM_SPARC32PLUS:
5836                 case EM_SPARCV9:
5837                 case EM_SPARC:
5838                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5839                     link_too_big = "BEFORE";
5840                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5841                     link_too_big = "AFTER";
5842                   break;
5843                 default:
5844                   break;
5845                 }
5846             }
5847
5848           if (do_section_details)
5849             {
5850               if (link_too_big != NULL && * link_too_big)
5851                 printf ("<%s> ", link_too_big);
5852               else
5853                 printf ("%2u ", section->sh_link);
5854               printf ("%3u %2lu\n", section->sh_info,
5855                       (unsigned long) section->sh_addralign);
5856             }
5857           else
5858             printf ("%2u %3u %2lu\n",
5859                     section->sh_link,
5860                     section->sh_info,
5861                     (unsigned long) section->sh_addralign);
5862
5863           if (link_too_big && ! * link_too_big)
5864             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5865                   i, section->sh_link);
5866         }
5867       else if (do_wide)
5868         {
5869           print_vma (section->sh_addr, LONG_HEX);
5870
5871           if ((long) section->sh_offset == section->sh_offset)
5872             printf (" %6.6lx", (unsigned long) section->sh_offset);
5873           else
5874             {
5875               putchar (' ');
5876               print_vma (section->sh_offset, LONG_HEX);
5877             }
5878
5879           if ((unsigned long) section->sh_size == section->sh_size)
5880             printf (" %6.6lx", (unsigned long) section->sh_size);
5881           else
5882             {
5883               putchar (' ');
5884               print_vma (section->sh_size, LONG_HEX);
5885             }
5886
5887           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5888             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5889           else
5890             {
5891               putchar (' ');
5892               print_vma (section->sh_entsize, LONG_HEX);
5893             }
5894
5895           if (do_section_details)
5896             fputs ("  ", stdout);
5897           else
5898             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5899
5900           printf ("%2u %3u ", section->sh_link, section->sh_info);
5901
5902           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5903             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5904           else
5905             {
5906               print_vma (section->sh_addralign, DEC);
5907               putchar ('\n');
5908             }
5909         }
5910       else if (do_section_details)
5911         {
5912           printf ("       %-15.15s  ",
5913                   get_section_type_name (section->sh_type));
5914           print_vma (section->sh_addr, LONG_HEX);
5915           if ((long) section->sh_offset == section->sh_offset)
5916             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5917           else
5918             {
5919               printf ("  ");
5920               print_vma (section->sh_offset, LONG_HEX);
5921             }
5922           printf ("  %u\n       ", section->sh_link);
5923           print_vma (section->sh_size, LONG_HEX);
5924           putchar (' ');
5925           print_vma (section->sh_entsize, LONG_HEX);
5926
5927           printf ("  %-16u  %lu\n",
5928                   section->sh_info,
5929                   (unsigned long) section->sh_addralign);
5930         }
5931       else
5932         {
5933           putchar (' ');
5934           print_vma (section->sh_addr, LONG_HEX);
5935           if ((long) section->sh_offset == section->sh_offset)
5936             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5937           else
5938             {
5939               printf ("  ");
5940               print_vma (section->sh_offset, LONG_HEX);
5941             }
5942           printf ("\n       ");
5943           print_vma (section->sh_size, LONG_HEX);
5944           printf ("  ");
5945           print_vma (section->sh_entsize, LONG_HEX);
5946
5947           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5948
5949           printf ("     %2u   %3u     %lu\n",
5950                   section->sh_link,
5951                   section->sh_info,
5952                   (unsigned long) section->sh_addralign);
5953         }
5954
5955       if (do_section_details)
5956         {
5957           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5958           if ((section->sh_flags & SHF_COMPRESSED) != 0)
5959             {
5960               /* Minimum section size is 12 bytes for 32-bit compression
5961                  header + 12 bytes for compressed data header.  */
5962               unsigned char buf[24];
5963               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5964               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5965                             sizeof (buf), _("compression header")))
5966                 {
5967                   Elf_Internal_Chdr chdr;
5968                   get_compression_header (&chdr, buf);
5969                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5970                     printf ("       ZLIB, ");
5971                   else
5972                     printf (_("       [<unknown>: 0x%x], "),
5973                             chdr.ch_type);
5974                   print_vma (chdr.ch_size, LONG_HEX);
5975                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5976                 }
5977             }
5978         }
5979     }
5980
5981   if (!do_section_details)
5982     {
5983       if (elf_header.e_machine == EM_X86_64
5984           || elf_header.e_machine == EM_L1OM
5985           || elf_header.e_machine == EM_K1OM)
5986         printf (_("Key to Flags:\n\
5987   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5988   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5989   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5990       else
5991         printf (_("Key to Flags:\n\
5992   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5993   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5994   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5995     }
5996
5997   return 1;
5998 }
5999
6000 static const char *
6001 get_group_flags (unsigned int flags)
6002 {
6003   static char buff[32];
6004   switch (flags)
6005     {
6006     case 0:
6007       return "";
6008
6009     case GRP_COMDAT:
6010       return "COMDAT ";
6011
6012    default:
6013       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
6014       break;
6015     }
6016   return buff;
6017 }
6018
6019 static int
6020 process_section_groups (FILE * file)
6021 {
6022   Elf_Internal_Shdr * section;
6023   unsigned int i;
6024   struct group * group;
6025   Elf_Internal_Shdr * symtab_sec;
6026   Elf_Internal_Shdr * strtab_sec;
6027   Elf_Internal_Sym * symtab;
6028   unsigned long num_syms;
6029   char * strtab;
6030   size_t strtab_size;
6031
6032   /* Don't process section groups unless needed.  */
6033   if (!do_unwind && !do_section_groups)
6034     return 1;
6035
6036   if (elf_header.e_shnum == 0)
6037     {
6038       if (do_section_groups)
6039         printf (_("\nThere are no sections to group in this file.\n"));
6040
6041       return 1;
6042     }
6043
6044   if (section_headers == NULL)
6045     {
6046       error (_("Section headers are not available!\n"));
6047       /* PR 13622: This can happen with a corrupt ELF header.  */
6048       return 0;
6049     }
6050
6051   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6052                                                      sizeof (struct group *));
6053
6054   if (section_headers_groups == NULL)
6055     {
6056       error (_("Out of memory reading %u section group headers\n"),
6057              elf_header.e_shnum);
6058       return 0;
6059     }
6060
6061   /* Scan the sections for the group section.  */
6062   group_count = 0;
6063   for (i = 0, section = section_headers;
6064        i < elf_header.e_shnum;
6065        i++, section++)
6066     if (section->sh_type == SHT_GROUP)
6067       group_count++;
6068
6069   if (group_count == 0)
6070     {
6071       if (do_section_groups)
6072         printf (_("\nThere are no section groups in this file.\n"));
6073
6074       return 1;
6075     }
6076
6077   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6078
6079   if (section_groups == NULL)
6080     {
6081       error (_("Out of memory reading %lu groups\n"),
6082              (unsigned long) group_count);
6083       return 0;
6084     }
6085
6086   symtab_sec = NULL;
6087   strtab_sec = NULL;
6088   symtab = NULL;
6089   num_syms = 0;
6090   strtab = NULL;
6091   strtab_size = 0;
6092   for (i = 0, section = section_headers, group = section_groups;
6093        i < elf_header.e_shnum;
6094        i++, section++)
6095     {
6096       if (section->sh_type == SHT_GROUP)
6097         {
6098           const char * name = printable_section_name (section);
6099           const char * group_name;
6100           unsigned char * start;
6101           unsigned char * indices;
6102           unsigned int entry, j, size;
6103           Elf_Internal_Shdr * sec;
6104           Elf_Internal_Sym * sym;
6105
6106           /* Get the symbol table.  */
6107           if (section->sh_link >= elf_header.e_shnum
6108               || ((sec = section_headers + section->sh_link)->sh_type
6109                   != SHT_SYMTAB))
6110             {
6111               error (_("Bad sh_link in group section `%s'\n"), name);
6112               continue;
6113             }
6114
6115           if (symtab_sec != sec)
6116             {
6117               symtab_sec = sec;
6118               if (symtab)
6119                 free (symtab);
6120               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6121             }
6122
6123           if (symtab == NULL)
6124             {
6125               error (_("Corrupt header in group section `%s'\n"), name);
6126               continue;
6127             }
6128
6129           if (section->sh_info >= num_syms)
6130             {
6131               error (_("Bad sh_info in group section `%s'\n"), name);
6132               continue;
6133             }
6134
6135           sym = symtab + section->sh_info;
6136
6137           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6138             {
6139               if (sym->st_shndx == 0
6140                   || sym->st_shndx >= elf_header.e_shnum)
6141                 {
6142                   error (_("Bad sh_info in group section `%s'\n"), name);
6143                   continue;
6144                 }
6145
6146               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6147               strtab_sec = NULL;
6148               if (strtab)
6149                 free (strtab);
6150               strtab = NULL;
6151               strtab_size = 0;
6152             }
6153           else
6154             {
6155               /* Get the string table.  */
6156               if (symtab_sec->sh_link >= elf_header.e_shnum)
6157                 {
6158                   strtab_sec = NULL;
6159                   if (strtab)
6160                     free (strtab);
6161                   strtab = NULL;
6162                   strtab_size = 0;
6163                 }
6164               else if (strtab_sec
6165                        != (sec = section_headers + symtab_sec->sh_link))
6166                 {
6167                   strtab_sec = sec;
6168                   if (strtab)
6169                     free (strtab);
6170
6171                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6172                                               1, strtab_sec->sh_size,
6173                                               _("string table"));
6174                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6175                 }
6176               group_name = sym->st_name < strtab_size
6177                 ? strtab + sym->st_name : _("<corrupt>");
6178             }
6179
6180           /* PR 17531: file: loop.  */
6181           if (section->sh_entsize > section->sh_size)
6182             {
6183               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6184                      printable_section_name (section),
6185                      (unsigned long) section->sh_entsize,
6186                      (unsigned long) section->sh_size);
6187               break;
6188             }
6189
6190           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6191                                               1, section->sh_size,
6192                                               _("section data"));
6193           if (start == NULL)
6194             continue;
6195
6196           indices = start;
6197           size = (section->sh_size / section->sh_entsize) - 1;
6198           entry = byte_get (indices, 4);
6199           indices += 4;
6200
6201           if (do_section_groups)
6202             {
6203               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6204                       get_group_flags (entry), i, name, group_name, size);
6205
6206               printf (_("   [Index]    Name\n"));
6207             }
6208
6209           group->group_index = i;
6210
6211           for (j = 0; j < size; j++)
6212             {
6213               struct group_list * g;
6214
6215               entry = byte_get (indices, 4);
6216               indices += 4;
6217
6218               if (entry >= elf_header.e_shnum)
6219                 {
6220                   static unsigned num_group_errors = 0;
6221
6222                   if (num_group_errors ++ < 10)
6223                     {
6224                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6225                              entry, i, elf_header.e_shnum - 1);
6226                       if (num_group_errors == 10)
6227                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6228                     }
6229                   continue;
6230                 }
6231
6232               if (section_headers_groups [entry] != NULL)
6233                 {
6234                   if (entry)
6235                     {
6236                       static unsigned num_errs = 0;
6237
6238                       if (num_errs ++ < 10)
6239                         {
6240                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6241                                  entry, i,
6242                                  section_headers_groups [entry]->group_index);
6243                           if (num_errs == 10)
6244                             warn (_("Further error messages about already contained group sections suppressed\n"));
6245                         }
6246                       continue;
6247                     }
6248                   else
6249                     {
6250                       /* Intel C/C++ compiler may put section 0 in a
6251                          section group. We just warn it the first time
6252                          and ignore it afterwards.  */
6253                       static int warned = 0;
6254                       if (!warned)
6255                         {
6256                           error (_("section 0 in group section [%5u]\n"),
6257                                  section_headers_groups [entry]->group_index);
6258                           warned++;
6259                         }
6260                     }
6261                 }
6262
6263               section_headers_groups [entry] = group;
6264
6265               if (do_section_groups)
6266                 {
6267                   sec = section_headers + entry;
6268                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6269                 }
6270
6271               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6272               g->section_index = entry;
6273               g->next = group->root;
6274               group->root = g;
6275             }
6276
6277           if (start)
6278             free (start);
6279
6280           group++;
6281         }
6282     }
6283
6284   if (symtab)
6285     free (symtab);
6286   if (strtab)
6287     free (strtab);
6288   return 1;
6289 }
6290
6291 /* Data used to display dynamic fixups.  */
6292
6293 struct ia64_vms_dynfixup
6294 {
6295   bfd_vma needed_ident;         /* Library ident number.  */
6296   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6297   bfd_vma fixup_needed;         /* Index of the library.  */
6298   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6299   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6300 };
6301
6302 /* Data used to display dynamic relocations.  */
6303
6304 struct ia64_vms_dynimgrela
6305 {
6306   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6307   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6308 };
6309
6310 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6311    library).  */
6312
6313 static void
6314 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6315                               const char *strtab, unsigned int strtab_sz)
6316 {
6317   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6318   long i;
6319   const char *lib_name;
6320
6321   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6322                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6323                    _("dynamic section image fixups"));
6324   if (!imfs)
6325     return;
6326
6327   if (fixup->needed < strtab_sz)
6328     lib_name = strtab + fixup->needed;
6329   else
6330     {
6331       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6332             (unsigned long) fixup->needed);
6333       lib_name = "???";
6334     }
6335   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6336           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6337   printf
6338     (_("Seg Offset           Type                             SymVec DataType\n"));
6339
6340   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6341     {
6342       unsigned int type;
6343       const char *rtype;
6344
6345       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6346       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6347       type = BYTE_GET (imfs [i].type);
6348       rtype = elf_ia64_reloc_type (type);
6349       if (rtype == NULL)
6350         printf (" 0x%08x                       ", type);
6351       else
6352         printf (" %-32s ", rtype);
6353       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6354       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6355     }
6356
6357   free (imfs);
6358 }
6359
6360 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6361
6362 static void
6363 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6364 {
6365   Elf64_External_VMS_IMAGE_RELA *imrs;
6366   long i;
6367
6368   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6369                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6370                    _("dynamic section image relocations"));
6371   if (!imrs)
6372     return;
6373
6374   printf (_("\nImage relocs\n"));
6375   printf
6376     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6377
6378   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6379     {
6380       unsigned int type;
6381       const char *rtype;
6382
6383       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6384       printf ("%08" BFD_VMA_FMT "x ",
6385               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6386       type = BYTE_GET (imrs [i].type);
6387       rtype = elf_ia64_reloc_type (type);
6388       if (rtype == NULL)
6389         printf ("0x%08x                      ", type);
6390       else
6391         printf ("%-31s ", rtype);
6392       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6393       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6394       printf ("%08" BFD_VMA_FMT "x\n",
6395               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6396     }
6397
6398   free (imrs);
6399 }
6400
6401 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6402
6403 static int
6404 process_ia64_vms_dynamic_relocs (FILE *file)
6405 {
6406   struct ia64_vms_dynfixup fixup;
6407   struct ia64_vms_dynimgrela imgrela;
6408   Elf_Internal_Dyn *entry;
6409   int res = 0;
6410   bfd_vma strtab_off = 0;
6411   bfd_vma strtab_sz = 0;
6412   char *strtab = NULL;
6413
6414   memset (&fixup, 0, sizeof (fixup));
6415   memset (&imgrela, 0, sizeof (imgrela));
6416
6417   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6418   for (entry = dynamic_section;
6419        entry < dynamic_section + dynamic_nent;
6420        entry++)
6421     {
6422       switch (entry->d_tag)
6423         {
6424         case DT_IA_64_VMS_STRTAB_OFFSET:
6425           strtab_off = entry->d_un.d_val;
6426           break;
6427         case DT_STRSZ:
6428           strtab_sz = entry->d_un.d_val;
6429           if (strtab == NULL)
6430             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6431                                1, strtab_sz, _("dynamic string section"));
6432           break;
6433
6434         case DT_IA_64_VMS_NEEDED_IDENT:
6435           fixup.needed_ident = entry->d_un.d_val;
6436           break;
6437         case DT_NEEDED:
6438           fixup.needed = entry->d_un.d_val;
6439           break;
6440         case DT_IA_64_VMS_FIXUP_NEEDED:
6441           fixup.fixup_needed = entry->d_un.d_val;
6442           break;
6443         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6444           fixup.fixup_rela_cnt = entry->d_un.d_val;
6445           break;
6446         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6447           fixup.fixup_rela_off = entry->d_un.d_val;
6448           res++;
6449           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6450           break;
6451
6452         case DT_IA_64_VMS_IMG_RELA_CNT:
6453           imgrela.img_rela_cnt = entry->d_un.d_val;
6454           break;
6455         case DT_IA_64_VMS_IMG_RELA_OFF:
6456           imgrela.img_rela_off = entry->d_un.d_val;
6457           res++;
6458           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6459           break;
6460
6461         default:
6462           break;
6463         }
6464     }
6465
6466   if (strtab != NULL)
6467     free (strtab);
6468
6469   return res;
6470 }
6471
6472 static struct
6473 {
6474   const char * name;
6475   int reloc;
6476   int size;
6477   int rela;
6478 } dynamic_relocations [] =
6479 {
6480     { "REL", DT_REL, DT_RELSZ, FALSE },
6481     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6482     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6483 };
6484
6485 /* Process the reloc section.  */
6486
6487 static int
6488 process_relocs (FILE * file)
6489 {
6490   unsigned long rel_size;
6491   unsigned long rel_offset;
6492
6493
6494   if (!do_reloc)
6495     return 1;
6496
6497   if (do_using_dynamic)
6498     {
6499       int is_rela;
6500       const char * name;
6501       int has_dynamic_reloc;
6502       unsigned int i;
6503
6504       has_dynamic_reloc = 0;
6505
6506       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6507         {
6508           is_rela = dynamic_relocations [i].rela;
6509           name = dynamic_relocations [i].name;
6510           rel_size = dynamic_info [dynamic_relocations [i].size];
6511           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6512
6513           has_dynamic_reloc |= rel_size;
6514
6515           if (is_rela == UNKNOWN)
6516             {
6517               if (dynamic_relocations [i].reloc == DT_JMPREL)
6518                 switch (dynamic_info[DT_PLTREL])
6519                   {
6520                   case DT_REL:
6521                     is_rela = FALSE;
6522                     break;
6523                   case DT_RELA:
6524                     is_rela = TRUE;
6525                     break;
6526                   }
6527             }
6528
6529           if (rel_size)
6530             {
6531               printf
6532                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6533                  name, rel_offset, rel_size);
6534
6535               dump_relocations (file,
6536                                 offset_from_vma (file, rel_offset, rel_size),
6537                                 rel_size,
6538                                 dynamic_symbols, num_dynamic_syms,
6539                                 dynamic_strings, dynamic_strings_length,
6540                                 is_rela, 1);
6541             }
6542         }
6543
6544       if (is_ia64_vms ())
6545         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6546
6547       if (! has_dynamic_reloc)
6548         printf (_("\nThere are no dynamic relocations in this file.\n"));
6549     }
6550   else
6551     {
6552       Elf_Internal_Shdr * section;
6553       unsigned long i;
6554       int found = 0;
6555
6556       for (i = 0, section = section_headers;
6557            i < elf_header.e_shnum;
6558            i++, section++)
6559         {
6560           if (   section->sh_type != SHT_RELA
6561               && section->sh_type != SHT_REL)
6562             continue;
6563
6564           rel_offset = section->sh_offset;
6565           rel_size   = section->sh_size;
6566
6567           if (rel_size)
6568             {
6569               Elf_Internal_Shdr * strsec;
6570               int is_rela;
6571
6572               printf (_("\nRelocation section "));
6573
6574               if (string_table == NULL)
6575                 printf ("%d", section->sh_name);
6576               else
6577                 printf ("'%s'", printable_section_name (section));
6578
6579               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6580                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6581
6582               is_rela = section->sh_type == SHT_RELA;
6583
6584               if (section->sh_link != 0
6585                   && section->sh_link < elf_header.e_shnum)
6586                 {
6587                   Elf_Internal_Shdr * symsec;
6588                   Elf_Internal_Sym *  symtab;
6589                   unsigned long nsyms;
6590                   unsigned long strtablen = 0;
6591                   char * strtab = NULL;
6592
6593                   symsec = section_headers + section->sh_link;
6594                   if (symsec->sh_type != SHT_SYMTAB
6595                       && symsec->sh_type != SHT_DYNSYM)
6596                     continue;
6597
6598                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6599
6600                   if (symtab == NULL)
6601                     continue;
6602
6603                   if (symsec->sh_link != 0
6604                       && symsec->sh_link < elf_header.e_shnum)
6605                     {
6606                       strsec = section_headers + symsec->sh_link;
6607
6608                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6609                                                   1, strsec->sh_size,
6610                                                   _("string table"));
6611                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6612                     }
6613
6614                   dump_relocations (file, rel_offset, rel_size,
6615                                     symtab, nsyms, strtab, strtablen,
6616                                     is_rela,
6617                                     symsec->sh_type == SHT_DYNSYM);
6618                   if (strtab)
6619                     free (strtab);
6620                   free (symtab);
6621                 }
6622               else
6623                 dump_relocations (file, rel_offset, rel_size,
6624                                   NULL, 0, NULL, 0, is_rela, 0);
6625
6626               found = 1;
6627             }
6628         }
6629
6630       if (! found)
6631         printf (_("\nThere are no relocations in this file.\n"));
6632     }
6633
6634   return 1;
6635 }
6636
6637 /* An absolute address consists of a section and an offset.  If the
6638    section is NULL, the offset itself is the address, otherwise, the
6639    address equals to LOAD_ADDRESS(section) + offset.  */
6640
6641 struct absaddr
6642 {
6643   unsigned short section;
6644   bfd_vma offset;
6645 };
6646
6647 #define ABSADDR(a) \
6648   ((a).section \
6649    ? section_headers [(a).section].sh_addr + (a).offset \
6650    : (a).offset)
6651
6652 /* Find the nearest symbol at or below ADDR.  Returns the symbol
6653    name, if found, and the offset from the symbol to ADDR.  */
6654
6655 static void
6656 find_symbol_for_address (Elf_Internal_Sym * symtab,
6657                          unsigned long      nsyms,
6658                          const char *       strtab,
6659                          unsigned long      strtab_size,
6660                          struct absaddr     addr,
6661                          const char **      symname,
6662                          bfd_vma *          offset)
6663 {
6664   bfd_vma dist = 0x100000;
6665   Elf_Internal_Sym * sym;
6666   Elf_Internal_Sym * beg;
6667   Elf_Internal_Sym * end;
6668   Elf_Internal_Sym * best = NULL;
6669
6670   REMOVE_ARCH_BITS (addr.offset);
6671   beg = symtab;
6672   end = symtab + nsyms;
6673
6674   while (beg < end)
6675     {
6676       bfd_vma value;
6677
6678       sym = beg + (end - beg) / 2;
6679
6680       value = sym->st_value;
6681       REMOVE_ARCH_BITS (value);
6682
6683       if (sym->st_name != 0
6684           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6685           && addr.offset >= value
6686           && addr.offset - value < dist)
6687         {
6688           best = sym;
6689           dist = addr.offset - value;
6690           if (!dist)
6691             break;
6692         }
6693
6694       if (addr.offset < value)
6695         end = sym;
6696       else
6697         beg = sym + 1;
6698     }
6699
6700   if (best)
6701     {
6702       *symname = (best->st_name >= strtab_size
6703                   ? _("<corrupt>") : strtab + best->st_name);
6704       *offset = dist;
6705       return;
6706     }
6707
6708   *symname = NULL;
6709   *offset = addr.offset;
6710 }
6711
6712 static int
6713 symcmp (const void *p, const void *q)
6714 {
6715   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6716   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6717
6718   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6719 }
6720
6721 /* Process the unwind section.  */
6722
6723 #include "unwind-ia64.h"
6724
6725 struct ia64_unw_table_entry
6726 {
6727   struct absaddr start;
6728   struct absaddr end;
6729   struct absaddr info;
6730 };
6731
6732 struct ia64_unw_aux_info
6733 {
6734   struct ia64_unw_table_entry *table;   /* Unwind table.  */
6735   unsigned long table_len;              /* Length of unwind table.  */
6736   unsigned char * info;                 /* Unwind info.  */
6737   unsigned long info_size;              /* Size of unwind info.  */
6738   bfd_vma info_addr;                    /* Starting address of unwind info.  */
6739   bfd_vma seg_base;                     /* Starting address of segment.  */
6740   Elf_Internal_Sym * symtab;            /* The symbol table.  */
6741   unsigned long nsyms;                  /* Number of symbols.  */
6742   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
6743   unsigned long nfuns;                  /* Number of entries in funtab.  */
6744   char * strtab;                        /* The string table.  */
6745   unsigned long strtab_size;            /* Size of string table.  */
6746 };
6747
6748 static void
6749 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6750 {
6751   struct ia64_unw_table_entry * tp;
6752   unsigned long j, nfuns;
6753   int in_body;
6754
6755   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6756   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6757     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6758       aux->funtab[nfuns++] = aux->symtab[j];
6759   aux->nfuns = nfuns;
6760   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6761
6762   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6763     {
6764       bfd_vma stamp;
6765       bfd_vma offset;
6766       const unsigned char * dp;
6767       const unsigned char * head;
6768       const unsigned char * end;
6769       const char * procname;
6770
6771       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6772                                aux->strtab_size, tp->start, &procname, &offset);
6773
6774       fputs ("\n<", stdout);
6775
6776       if (procname)
6777         {
6778           fputs (procname, stdout);
6779
6780           if (offset)
6781             printf ("+%lx", (unsigned long) offset);
6782         }
6783
6784       fputs (">: [", stdout);
6785       print_vma (tp->start.offset, PREFIX_HEX);
6786       fputc ('-', stdout);
6787       print_vma (tp->end.offset, PREFIX_HEX);
6788       printf ("], info at +0x%lx\n",
6789               (unsigned long) (tp->info.offset - aux->seg_base));
6790
6791       /* PR 17531: file: 86232b32.  */
6792       if (aux->info == NULL)
6793         continue;
6794
6795       /* PR 17531: file: 0997b4d1.  */
6796       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6797         {
6798           warn (_("Invalid offset %lx in table entry %ld\n"),
6799                 (long) tp->info.offset, (long) (tp - aux->table));
6800           continue;
6801         }
6802
6803       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6804       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6805
6806       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6807               (unsigned) UNW_VER (stamp),
6808               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6809               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6810               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6811               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6812
6813       if (UNW_VER (stamp) != 1)
6814         {
6815           printf (_("\tUnknown version.\n"));
6816           continue;
6817         }
6818
6819       in_body = 0;
6820       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6821       /* PR 17531: file: 16ceda89.  */
6822       if (end > aux->info + aux->info_size)
6823         end = aux->info + aux->info_size;
6824       for (dp = head + 8; dp < end;)
6825         dp = unw_decode (dp, in_body, & in_body, end);
6826     }
6827
6828   free (aux->funtab);
6829 }
6830
6831 static bfd_boolean
6832 slurp_ia64_unwind_table (FILE * file,
6833                          struct ia64_unw_aux_info * aux,
6834                          Elf_Internal_Shdr * sec)
6835 {
6836   unsigned long size, nrelas, i;
6837   Elf_Internal_Phdr * seg;
6838   struct ia64_unw_table_entry * tep;
6839   Elf_Internal_Shdr * relsec;
6840   Elf_Internal_Rela * rela;
6841   Elf_Internal_Rela * rp;
6842   unsigned char * table;
6843   unsigned char * tp;
6844   Elf_Internal_Sym * sym;
6845   const char * relname;
6846
6847   aux->table_len = 0;
6848
6849   /* First, find the starting address of the segment that includes
6850      this section: */
6851
6852   if (elf_header.e_phnum)
6853     {
6854       if (! get_program_headers (file))
6855           return FALSE;
6856
6857       for (seg = program_headers;
6858            seg < program_headers + elf_header.e_phnum;
6859            ++seg)
6860         {
6861           if (seg->p_type != PT_LOAD)
6862             continue;
6863
6864           if (sec->sh_addr >= seg->p_vaddr
6865               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6866             {
6867               aux->seg_base = seg->p_vaddr;
6868               break;
6869             }
6870         }
6871     }
6872
6873   /* Second, build the unwind table from the contents of the unwind section:  */
6874   size = sec->sh_size;
6875   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6876                                       _("unwind table"));
6877   if (!table)
6878     return FALSE;
6879
6880   aux->table_len = size / (3 * eh_addr_size);
6881   aux->table = (struct ia64_unw_table_entry *)
6882     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6883   tep = aux->table;
6884
6885   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6886     {
6887       tep->start.section = SHN_UNDEF;
6888       tep->end.section   = SHN_UNDEF;
6889       tep->info.section  = SHN_UNDEF;
6890       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6891       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6892       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6893       tep->start.offset += aux->seg_base;
6894       tep->end.offset   += aux->seg_base;
6895       tep->info.offset  += aux->seg_base;
6896     }
6897   free (table);
6898
6899   /* Third, apply any relocations to the unwind table:  */
6900   for (relsec = section_headers;
6901        relsec < section_headers + elf_header.e_shnum;
6902        ++relsec)
6903     {
6904       if (relsec->sh_type != SHT_RELA
6905           || relsec->sh_info >= elf_header.e_shnum
6906           || section_headers + relsec->sh_info != sec)
6907         continue;
6908
6909       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6910                               & rela, & nrelas))
6911         {
6912           free (aux->table);
6913           aux->table = NULL;
6914           aux->table_len = 0;
6915           return FALSE;
6916         }
6917
6918       for (rp = rela; rp < rela + nrelas; ++rp)
6919         {
6920           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6921           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6922
6923           /* PR 17531: file: 9fa67536.  */
6924           if (relname == NULL)
6925             {
6926               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6927               continue;
6928             }
6929
6930           if (! const_strneq (relname, "R_IA64_SEGREL"))
6931             {
6932               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6933               continue;
6934             }
6935
6936           i = rp->r_offset / (3 * eh_addr_size);
6937
6938           /* PR 17531: file: 5bc8d9bf.  */
6939           if (i >= aux->table_len)
6940             {
6941               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6942               continue;
6943             }
6944
6945           switch (rp->r_offset / eh_addr_size % 3)
6946             {
6947             case 0:
6948               aux->table[i].start.section = sym->st_shndx;
6949               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6950               break;
6951             case 1:
6952               aux->table[i].end.section   = sym->st_shndx;
6953               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6954               break;
6955             case 2:
6956               aux->table[i].info.section  = sym->st_shndx;
6957               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6958               break;
6959             default:
6960               break;
6961             }
6962         }
6963
6964       free (rela);
6965     }
6966
6967   return TRUE;
6968 }
6969
6970 static void
6971 ia64_process_unwind (FILE * file)
6972 {
6973   Elf_Internal_Shdr * sec;
6974   Elf_Internal_Shdr * unwsec = NULL;
6975   Elf_Internal_Shdr * strsec;
6976   unsigned long i, unwcount = 0, unwstart = 0;
6977   struct ia64_unw_aux_info aux;
6978
6979   memset (& aux, 0, sizeof (aux));
6980
6981   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6982     {
6983       if (sec->sh_type == SHT_SYMTAB
6984           && sec->sh_link < elf_header.e_shnum)
6985         {
6986           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6987
6988           strsec = section_headers + sec->sh_link;
6989           if (aux.strtab != NULL)
6990             {
6991               error (_("Multiple auxillary string tables encountered\n"));
6992               free (aux.strtab);
6993             }
6994           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6995                                           1, strsec->sh_size,
6996                                           _("string table"));
6997           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6998         }
6999       else if (sec->sh_type == SHT_IA_64_UNWIND)
7000         unwcount++;
7001     }
7002
7003   if (!unwcount)
7004     printf (_("\nThere are no unwind sections in this file.\n"));
7005
7006   while (unwcount-- > 0)
7007     {
7008       char * suffix;
7009       size_t len, len2;
7010
7011       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7012            i < elf_header.e_shnum; ++i, ++sec)
7013         if (sec->sh_type == SHT_IA_64_UNWIND)
7014           {
7015             unwsec = sec;
7016             break;
7017           }
7018       /* We have already counted the number of SHT_IA64_UNWIND
7019          sections so the loop above should never fail.  */
7020       assert (unwsec != NULL);
7021
7022       unwstart = i + 1;
7023       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7024
7025       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7026         {
7027           /* We need to find which section group it is in.  */
7028           struct group_list * g;
7029
7030           if (section_headers_groups == NULL
7031               || section_headers_groups [i] == NULL)
7032             i = elf_header.e_shnum;
7033           else
7034             {
7035               g = section_headers_groups [i]->root;
7036
7037               for (; g != NULL; g = g->next)
7038                 {
7039                   sec = section_headers + g->section_index;
7040
7041                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7042                     break;
7043                 }
7044
7045               if (g == NULL)
7046                 i = elf_header.e_shnum;
7047             }
7048         }
7049       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7050         {
7051           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7052           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7053           suffix = SECTION_NAME (unwsec) + len;
7054           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7055                ++i, ++sec)
7056             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7057                 && streq (SECTION_NAME (sec) + len2, suffix))
7058               break;
7059         }
7060       else
7061         {
7062           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7063              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7064           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7065           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7066           suffix = "";
7067           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7068             suffix = SECTION_NAME (unwsec) + len;
7069           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7070                ++i, ++sec)
7071             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7072                 && streq (SECTION_NAME (sec) + len2, suffix))
7073               break;
7074         }
7075
7076       if (i == elf_header.e_shnum)
7077         {
7078           printf (_("\nCould not find unwind info section for "));
7079
7080           if (string_table == NULL)
7081             printf ("%d", unwsec->sh_name);
7082           else
7083             printf ("'%s'", printable_section_name (unwsec));
7084         }
7085       else
7086         {
7087           aux.info_addr = sec->sh_addr;
7088           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7089                                                  sec->sh_size,
7090                                                  _("unwind info"));
7091           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7092
7093           printf (_("\nUnwind section "));
7094
7095           if (string_table == NULL)
7096             printf ("%d", unwsec->sh_name);
7097           else
7098             printf ("'%s'", printable_section_name (unwsec));
7099
7100           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101                   (unsigned long) unwsec->sh_offset,
7102                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7103
7104           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7105               && aux.table_len > 0)
7106             dump_ia64_unwind (& aux);
7107
7108           if (aux.table)
7109             free ((char *) aux.table);
7110           if (aux.info)
7111             free ((char *) aux.info);
7112           aux.table = NULL;
7113           aux.info = NULL;
7114         }
7115     }
7116
7117   if (aux.symtab)
7118     free (aux.symtab);
7119   if (aux.strtab)
7120     free ((char *) aux.strtab);
7121 }
7122
7123 struct hppa_unw_table_entry
7124   {
7125     struct absaddr start;
7126     struct absaddr end;
7127     unsigned int Cannot_unwind:1;               /* 0 */
7128     unsigned int Millicode:1;                   /* 1 */
7129     unsigned int Millicode_save_sr0:1;          /* 2 */
7130     unsigned int Region_description:2;          /* 3..4 */
7131     unsigned int reserved1:1;                   /* 5 */
7132     unsigned int Entry_SR:1;                    /* 6 */
7133     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
7134     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
7135     unsigned int Args_stored:1;                 /* 16 */
7136     unsigned int Variable_Frame:1;              /* 17 */
7137     unsigned int Separate_Package_Body:1;       /* 18 */
7138     unsigned int Frame_Extension_Millicode:1;   /* 19 */
7139     unsigned int Stack_Overflow_Check:1;        /* 20 */
7140     unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7141     unsigned int Ada_Region:1;                  /* 22 */
7142     unsigned int cxx_info:1;                    /* 23 */
7143     unsigned int cxx_try_catch:1;               /* 24 */
7144     unsigned int sched_entry_seq:1;             /* 25 */
7145     unsigned int reserved2:1;                   /* 26 */
7146     unsigned int Save_SP:1;                     /* 27 */
7147     unsigned int Save_RP:1;                     /* 28 */
7148     unsigned int Save_MRP_in_frame:1;           /* 29 */
7149     unsigned int extn_ptr_defined:1;            /* 30 */
7150     unsigned int Cleanup_defined:1;             /* 31 */
7151
7152     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
7153     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
7154     unsigned int Large_frame:1;                 /* 2 */
7155     unsigned int Pseudo_SP_Set:1;               /* 3 */
7156     unsigned int reserved4:1;                   /* 4 */
7157     unsigned int Total_frame_size:27;           /* 5..31 */
7158   };
7159
7160 struct hppa_unw_aux_info
7161 {
7162   struct hppa_unw_table_entry * table;  /* Unwind table.  */
7163   unsigned long table_len;              /* Length of unwind table.  */
7164   bfd_vma seg_base;                     /* Starting address of segment.  */
7165   Elf_Internal_Sym * symtab;            /* The symbol table.  */
7166   unsigned long nsyms;                  /* Number of symbols.  */
7167   Elf_Internal_Sym * funtab;            /* Sorted table of STT_FUNC symbols.  */
7168   unsigned long nfuns;                  /* Number of entries in funtab.  */
7169   char * strtab;                        /* The string table.  */
7170   unsigned long strtab_size;            /* Size of string table.  */
7171 };
7172
7173 static void
7174 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7175 {
7176   struct hppa_unw_table_entry * tp;
7177   unsigned long j, nfuns;
7178
7179   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7180   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7181     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7182       aux->funtab[nfuns++] = aux->symtab[j];
7183   aux->nfuns = nfuns;
7184   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7185
7186   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7187     {
7188       bfd_vma offset;
7189       const char * procname;
7190
7191       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7192                                aux->strtab_size, tp->start, &procname,
7193                                &offset);
7194
7195       fputs ("\n<", stdout);
7196
7197       if (procname)
7198         {
7199           fputs (procname, stdout);
7200
7201           if (offset)
7202             printf ("+%lx", (unsigned long) offset);
7203         }
7204
7205       fputs (">: [", stdout);
7206       print_vma (tp->start.offset, PREFIX_HEX);
7207       fputc ('-', stdout);
7208       print_vma (tp->end.offset, PREFIX_HEX);
7209       printf ("]\n\t");
7210
7211 #define PF(_m) if (tp->_m) printf (#_m " ");
7212 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7213       PF(Cannot_unwind);
7214       PF(Millicode);
7215       PF(Millicode_save_sr0);
7216       /* PV(Region_description);  */
7217       PF(Entry_SR);
7218       PV(Entry_FR);
7219       PV(Entry_GR);
7220       PF(Args_stored);
7221       PF(Variable_Frame);
7222       PF(Separate_Package_Body);
7223       PF(Frame_Extension_Millicode);
7224       PF(Stack_Overflow_Check);
7225       PF(Two_Instruction_SP_Increment);
7226       PF(Ada_Region);
7227       PF(cxx_info);
7228       PF(cxx_try_catch);
7229       PF(sched_entry_seq);
7230       PF(Save_SP);
7231       PF(Save_RP);
7232       PF(Save_MRP_in_frame);
7233       PF(extn_ptr_defined);
7234       PF(Cleanup_defined);
7235       PF(MPE_XL_interrupt_marker);
7236       PF(HP_UX_interrupt_marker);
7237       PF(Large_frame);
7238       PF(Pseudo_SP_Set);
7239       PV(Total_frame_size);
7240 #undef PF
7241 #undef PV
7242     }
7243
7244   printf ("\n");
7245
7246   free (aux->funtab);
7247 }
7248
7249 static int
7250 slurp_hppa_unwind_table (FILE * file,
7251                          struct hppa_unw_aux_info * aux,
7252                          Elf_Internal_Shdr * sec)
7253 {
7254   unsigned long size, unw_ent_size, nentries, nrelas, i;
7255   Elf_Internal_Phdr * seg;
7256   struct hppa_unw_table_entry * tep;
7257   Elf_Internal_Shdr * relsec;
7258   Elf_Internal_Rela * rela;
7259   Elf_Internal_Rela * rp;
7260   unsigned char * table;
7261   unsigned char * tp;
7262   Elf_Internal_Sym * sym;
7263   const char * relname;
7264
7265   /* First, find the starting address of the segment that includes
7266      this section.  */
7267
7268   if (elf_header.e_phnum)
7269     {
7270       if (! get_program_headers (file))
7271         return 0;
7272
7273       for (seg = program_headers;
7274            seg < program_headers + elf_header.e_phnum;
7275            ++seg)
7276         {
7277           if (seg->p_type != PT_LOAD)
7278             continue;
7279
7280           if (sec->sh_addr >= seg->p_vaddr
7281               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7282             {
7283               aux->seg_base = seg->p_vaddr;
7284               break;
7285             }
7286         }
7287     }
7288
7289   /* Second, build the unwind table from the contents of the unwind
7290      section.  */
7291   size = sec->sh_size;
7292   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7293                                       _("unwind table"));
7294   if (!table)
7295     return 0;
7296
7297   unw_ent_size = 16;
7298   nentries = size / unw_ent_size;
7299   size = unw_ent_size * nentries;
7300
7301   tep = aux->table = (struct hppa_unw_table_entry *)
7302       xcmalloc (nentries, sizeof (aux->table[0]));
7303
7304   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7305     {
7306       unsigned int tmp1, tmp2;
7307
7308       tep->start.section = SHN_UNDEF;
7309       tep->end.section   = SHN_UNDEF;
7310
7311       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7312       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7313       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7314       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7315
7316       tep->start.offset += aux->seg_base;
7317       tep->end.offset   += aux->seg_base;
7318
7319       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7320       tep->Millicode = (tmp1 >> 30) & 0x1;
7321       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7322       tep->Region_description = (tmp1 >> 27) & 0x3;
7323       tep->reserved1 = (tmp1 >> 26) & 0x1;
7324       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7325       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7326       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7327       tep->Args_stored = (tmp1 >> 15) & 0x1;
7328       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7329       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7330       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7331       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7332       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7333       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7334       tep->cxx_info = (tmp1 >> 8) & 0x1;
7335       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7336       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7337       tep->reserved2 = (tmp1 >> 5) & 0x1;
7338       tep->Save_SP = (tmp1 >> 4) & 0x1;
7339       tep->Save_RP = (tmp1 >> 3) & 0x1;
7340       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7341       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7342       tep->Cleanup_defined = tmp1 & 0x1;
7343
7344       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7345       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7346       tep->Large_frame = (tmp2 >> 29) & 0x1;
7347       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7348       tep->reserved4 = (tmp2 >> 27) & 0x1;
7349       tep->Total_frame_size = tmp2 & 0x7ffffff;
7350     }
7351   free (table);
7352
7353   /* Third, apply any relocations to the unwind table.  */
7354   for (relsec = section_headers;
7355        relsec < section_headers + elf_header.e_shnum;
7356        ++relsec)
7357     {
7358       if (relsec->sh_type != SHT_RELA
7359           || relsec->sh_info >= elf_header.e_shnum
7360           || section_headers + relsec->sh_info != sec)
7361         continue;
7362
7363       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7364                               & rela, & nrelas))
7365         return 0;
7366
7367       for (rp = rela; rp < rela + nrelas; ++rp)
7368         {
7369           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7370           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7371
7372           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7373           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7374             {
7375               warn (_("Skipping unexpected relocation type %s\n"), relname);
7376               continue;
7377             }
7378
7379           i = rp->r_offset / unw_ent_size;
7380
7381           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7382             {
7383             case 0:
7384               aux->table[i].start.section = sym->st_shndx;
7385               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7386               break;
7387             case 1:
7388               aux->table[i].end.section   = sym->st_shndx;
7389               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7390               break;
7391             default:
7392               break;
7393             }
7394         }
7395
7396       free (rela);
7397     }
7398
7399   aux->table_len = nentries;
7400
7401   return 1;
7402 }
7403
7404 static void
7405 hppa_process_unwind (FILE * file)
7406 {
7407   struct hppa_unw_aux_info aux;
7408   Elf_Internal_Shdr * unwsec = NULL;
7409   Elf_Internal_Shdr * strsec;
7410   Elf_Internal_Shdr * sec;
7411   unsigned long i;
7412
7413   if (string_table == NULL)
7414     return;
7415
7416   memset (& aux, 0, sizeof (aux));
7417
7418   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7419     {
7420       if (sec->sh_type == SHT_SYMTAB
7421           && sec->sh_link < elf_header.e_shnum)
7422         {
7423           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7424
7425           strsec = section_headers + sec->sh_link;
7426           if (aux.strtab != NULL)
7427             {
7428               error (_("Multiple auxillary string tables encountered\n"));
7429               free (aux.strtab);
7430             }
7431           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7432                                           1, strsec->sh_size,
7433                                           _("string table"));
7434           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7435         }
7436       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7437         unwsec = sec;
7438     }
7439
7440   if (!unwsec)
7441     printf (_("\nThere are no unwind sections in this file.\n"));
7442
7443   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7444     {
7445       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7446         {
7447           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7448                   printable_section_name (sec),
7449                   (unsigned long) sec->sh_offset,
7450                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7451
7452           slurp_hppa_unwind_table (file, &aux, sec);
7453           if (aux.table_len > 0)
7454             dump_hppa_unwind (&aux);
7455
7456           if (aux.table)
7457             free ((char *) aux.table);
7458           aux.table = NULL;
7459         }
7460     }
7461
7462   if (aux.symtab)
7463     free (aux.symtab);
7464   if (aux.strtab)
7465     free ((char *) aux.strtab);
7466 }
7467
7468 struct arm_section
7469 {
7470   unsigned char *      data;            /* The unwind data.  */
7471   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7472   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7473   unsigned long        nrelas;          /* The number of relocations.  */
7474   unsigned int         rel_type;        /* REL or RELA ?  */
7475   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7476 };
7477
7478 struct arm_unw_aux_info
7479 {
7480   FILE *              file;             /* The file containing the unwind sections.  */
7481   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7482   unsigned long       nsyms;            /* Number of symbols.  */
7483   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7484   unsigned long       nfuns;            /* Number of these symbols.  */
7485   char *              strtab;           /* The file's string table.  */
7486   unsigned long       strtab_size;      /* Size of string table.  */
7487 };
7488
7489 static const char *
7490 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7491                         bfd_vma fn, struct absaddr addr)
7492 {
7493   const char *procname;
7494   bfd_vma sym_offset;
7495
7496   if (addr.section == SHN_UNDEF)
7497     addr.offset = fn;
7498
7499   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7500                            aux->strtab_size, addr, &procname,
7501                            &sym_offset);
7502
7503   print_vma (fn, PREFIX_HEX);
7504
7505   if (procname)
7506     {
7507       fputs (" <", stdout);
7508       fputs (procname, stdout);
7509
7510       if (sym_offset)
7511         printf ("+0x%lx", (unsigned long) sym_offset);
7512       fputc ('>', stdout);
7513     }
7514
7515   return procname;
7516 }
7517
7518 static void
7519 arm_free_section (struct arm_section *arm_sec)
7520 {
7521   if (arm_sec->data != NULL)
7522     free (arm_sec->data);
7523
7524   if (arm_sec->rela != NULL)
7525     free (arm_sec->rela);
7526 }
7527
7528 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7529       cached section and install SEC instead.
7530    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7531       and return its valued in * WORDP, relocating if necessary.
7532    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7533       relocation's offset in ADDR.
7534    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7535       into the string table of the symbol associated with the reloc.  If no
7536       reloc was applied store -1 there.
7537    5) Return TRUE upon success, FALSE otherwise.  */
7538
7539 static bfd_boolean
7540 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7541                          struct arm_section *       arm_sec,
7542                          Elf_Internal_Shdr *        sec,
7543                          bfd_vma                    word_offset,
7544                          unsigned int *             wordp,
7545                          struct absaddr *           addr,
7546                          bfd_vma *                  sym_name)
7547 {
7548   Elf_Internal_Rela *rp;
7549   Elf_Internal_Sym *sym;
7550   const char * relname;
7551   unsigned int word;
7552   bfd_boolean wrapped;
7553
7554   if (sec == NULL || arm_sec == NULL)
7555     return FALSE;
7556
7557   addr->section = SHN_UNDEF;
7558   addr->offset = 0;
7559
7560   if (sym_name != NULL)
7561     *sym_name = (bfd_vma) -1;
7562
7563   /* If necessary, update the section cache.  */
7564   if (sec != arm_sec->sec)
7565     {
7566       Elf_Internal_Shdr *relsec;
7567
7568       arm_free_section (arm_sec);
7569
7570       arm_sec->sec = sec;
7571       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7572                                 sec->sh_size, _("unwind data"));
7573       arm_sec->rela = NULL;
7574       arm_sec->nrelas = 0;
7575
7576       for (relsec = section_headers;
7577            relsec < section_headers + elf_header.e_shnum;
7578            ++relsec)
7579         {
7580           if (relsec->sh_info >= elf_header.e_shnum
7581               || section_headers + relsec->sh_info != sec
7582               /* PR 15745: Check the section type as well.  */
7583               || (relsec->sh_type != SHT_REL
7584                   && relsec->sh_type != SHT_RELA))
7585             continue;
7586
7587           arm_sec->rel_type = relsec->sh_type;
7588           if (relsec->sh_type == SHT_REL)
7589             {
7590               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7591                                      relsec->sh_size,
7592                                      & arm_sec->rela, & arm_sec->nrelas))
7593                 return FALSE;
7594             }
7595           else /* relsec->sh_type == SHT_RELA */
7596             {
7597               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7598                                       relsec->sh_size,
7599                                       & arm_sec->rela, & arm_sec->nrelas))
7600                 return FALSE;
7601             }
7602           break;
7603         }
7604
7605       arm_sec->next_rela = arm_sec->rela;
7606     }
7607
7608   /* If there is no unwind data we can do nothing.  */
7609   if (arm_sec->data == NULL)
7610     return FALSE;
7611
7612   /* If the offset is invalid then fail.  */
7613   if (word_offset > (sec->sh_size - 4)
7614       /* PR 18879 */
7615       || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7616       || ((bfd_signed_vma) word_offset) < 0)
7617     return FALSE;
7618
7619   /* Get the word at the required offset.  */
7620   word = byte_get (arm_sec->data + word_offset, 4);
7621
7622   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7623   if (arm_sec->rela == NULL)
7624     {
7625       * wordp = word;
7626       return TRUE;
7627     }
7628
7629   /* Look through the relocs to find the one that applies to the provided offset.  */
7630   wrapped = FALSE;
7631   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7632     {
7633       bfd_vma prelval, offset;
7634
7635       if (rp->r_offset > word_offset && !wrapped)
7636         {
7637           rp = arm_sec->rela;
7638           wrapped = TRUE;
7639         }
7640       if (rp->r_offset > word_offset)
7641         break;
7642
7643       if (rp->r_offset & 3)
7644         {
7645           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7646                 (unsigned long) rp->r_offset);
7647           continue;
7648         }
7649
7650       if (rp->r_offset < word_offset)
7651         continue;
7652
7653       /* PR 17531: file: 027-161405-0.004  */
7654       if (aux->symtab == NULL)
7655         continue;
7656
7657       if (arm_sec->rel_type == SHT_REL)
7658         {
7659           offset = word & 0x7fffffff;
7660           if (offset & 0x40000000)
7661             offset |= ~ (bfd_vma) 0x7fffffff;
7662         }
7663       else if (arm_sec->rel_type == SHT_RELA)
7664         offset = rp->r_addend;
7665       else
7666         {
7667           error (_("Unknown section relocation type %d encountered\n"),
7668                  arm_sec->rel_type);
7669           break;
7670         }
7671
7672       /* PR 17531 file: 027-1241568-0.004.  */
7673       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7674         {
7675           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7676                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7677           break;
7678         }
7679
7680       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7681       offset += sym->st_value;
7682       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7683
7684       /* Check that we are processing the expected reloc type.  */
7685       if (elf_header.e_machine == EM_ARM)
7686         {
7687           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7688           if (relname == NULL)
7689             {
7690               warn (_("Skipping unknown ARM relocation type: %d\n"),
7691                     (int) ELF32_R_TYPE (rp->r_info));
7692               continue;
7693             }
7694
7695           if (streq (relname, "R_ARM_NONE"))
7696               continue;
7697
7698           if (! streq (relname, "R_ARM_PREL31"))
7699             {
7700               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7701               continue;
7702             }
7703         }
7704       else if (elf_header.e_machine == EM_TI_C6000)
7705         {
7706           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7707           if (relname == NULL)
7708             {
7709               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7710                     (int) ELF32_R_TYPE (rp->r_info));
7711               continue;
7712             }
7713
7714           if (streq (relname, "R_C6000_NONE"))
7715             continue;
7716
7717           if (! streq (relname, "R_C6000_PREL31"))
7718             {
7719               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7720               continue;
7721             }
7722
7723           prelval >>= 1;
7724         }
7725       else
7726         {
7727           /* This function currently only supports ARM and TI unwinders.  */
7728           warn (_("Only TI and ARM unwinders are currently supported\n"));
7729           break;
7730         }
7731
7732       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7733       addr->section = sym->st_shndx;
7734       addr->offset = offset;
7735
7736       if (sym_name)
7737         * sym_name = sym->st_name;
7738       break;
7739     }
7740
7741   *wordp = word;
7742   arm_sec->next_rela = rp;
7743
7744   return TRUE;
7745 }
7746
7747 static const char *tic6x_unwind_regnames[16] =
7748 {
7749   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7750   "A14", "A13", "A12", "A11", "A10",
7751   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7752 };
7753
7754 static void
7755 decode_tic6x_unwind_regmask (unsigned int mask)
7756 {
7757   int i;
7758
7759   for (i = 12; mask; mask >>= 1, i--)
7760     {
7761       if (mask & 1)
7762         {
7763           fputs (tic6x_unwind_regnames[i], stdout);
7764           if (mask > 1)
7765             fputs (", ", stdout);
7766         }
7767     }
7768 }
7769
7770 #define ADVANCE                                                 \
7771   if (remaining == 0 && more_words)                             \
7772     {                                                           \
7773       data_offset += 4;                                         \
7774       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7775                                      data_offset, & word, & addr, NULL))        \
7776         return;                                                 \
7777       remaining = 4;                                            \
7778       more_words--;                                             \
7779     }                                                           \
7780
7781 #define GET_OP(OP)                      \
7782   ADVANCE;                              \
7783   if (remaining)                        \
7784     {                                   \
7785       remaining--;                      \
7786       (OP) = word >> 24;                \
7787       word <<= 8;                       \
7788     }                                   \
7789   else                                  \
7790     {                                   \
7791       printf (_("[Truncated opcode]\n"));       \
7792       return;                           \
7793     }                                   \
7794   printf ("0x%02x ", OP)
7795
7796 static void
7797 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
7798                             unsigned int               word,
7799                             unsigned int               remaining,
7800                             unsigned int               more_words,
7801                             bfd_vma                    data_offset,
7802                             Elf_Internal_Shdr *        data_sec,
7803                             struct arm_section *       data_arm_sec)
7804 {
7805   struct absaddr addr;
7806
7807   /* Decode the unwinding instructions.  */
7808   while (1)
7809     {
7810       unsigned int op, op2;
7811
7812       ADVANCE;
7813       if (remaining == 0)
7814         break;
7815       remaining--;
7816       op = word >> 24;
7817       word <<= 8;
7818
7819       printf ("  0x%02x ", op);
7820
7821       if ((op & 0xc0) == 0x00)
7822         {
7823           int offset = ((op & 0x3f) << 2) + 4;
7824
7825           printf ("     vsp = vsp + %d", offset);
7826         }
7827       else if ((op & 0xc0) == 0x40)
7828         {
7829           int offset = ((op & 0x3f) << 2) + 4;
7830
7831           printf ("     vsp = vsp - %d", offset);
7832         }
7833       else if ((op & 0xf0) == 0x80)
7834         {
7835           GET_OP (op2);
7836           if (op == 0x80 && op2 == 0)
7837             printf (_("Refuse to unwind"));
7838           else
7839             {
7840               unsigned int mask = ((op & 0x0f) << 8) | op2;
7841               int first = 1;
7842               int i;
7843
7844               printf ("pop {");
7845               for (i = 0; i < 12; i++)
7846                 if (mask & (1 << i))
7847                   {
7848                     if (first)
7849                       first = 0;
7850                     else
7851                       printf (", ");
7852                     printf ("r%d", 4 + i);
7853                   }
7854               printf ("}");
7855             }
7856         }
7857       else if ((op & 0xf0) == 0x90)
7858         {
7859           if (op == 0x9d || op == 0x9f)
7860             printf (_("     [Reserved]"));
7861           else
7862             printf ("     vsp = r%d", op & 0x0f);
7863         }
7864       else if ((op & 0xf0) == 0xa0)
7865         {
7866           int end = 4 + (op & 0x07);
7867           int first = 1;
7868           int i;
7869
7870           printf ("     pop {");
7871           for (i = 4; i <= end; i++)
7872             {
7873               if (first)
7874                 first = 0;
7875               else
7876                 printf (", ");
7877               printf ("r%d", i);
7878             }
7879           if (op & 0x08)
7880             {
7881               if (!first)
7882                 printf (", ");
7883               printf ("r14");
7884             }
7885           printf ("}");
7886         }
7887       else if (op == 0xb0)
7888         printf (_("     finish"));
7889       else if (op == 0xb1)
7890         {
7891           GET_OP (op2);
7892           if (op2 == 0 || (op2 & 0xf0) != 0)
7893             printf (_("[Spare]"));
7894           else
7895             {
7896               unsigned int mask = op2 & 0x0f;
7897               int first = 1;
7898               int i;
7899
7900               printf ("pop {");
7901               for (i = 0; i < 12; i++)
7902                 if (mask & (1 << i))
7903                   {
7904                     if (first)
7905                       first = 0;
7906                     else
7907                       printf (", ");
7908                     printf ("r%d", i);
7909                   }
7910               printf ("}");
7911             }
7912         }
7913       else if (op == 0xb2)
7914         {
7915           unsigned char buf[9];
7916           unsigned int i, len;
7917           unsigned long offset;
7918
7919           for (i = 0; i < sizeof (buf); i++)
7920             {
7921               GET_OP (buf[i]);
7922               if ((buf[i] & 0x80) == 0)
7923                 break;
7924             }
7925           if (i == sizeof (buf))
7926             printf (_("corrupt change to vsp"));
7927           else
7928             {
7929               offset = read_uleb128 (buf, &len, buf + i + 1);
7930               assert (len == i + 1);
7931               offset = offset * 4 + 0x204;
7932               printf ("vsp = vsp + %ld", offset);
7933             }
7934         }
7935       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7936         {
7937           unsigned int first, last;
7938
7939           GET_OP (op2);
7940           first = op2 >> 4;
7941           last = op2 & 0x0f;
7942           if (op == 0xc8)
7943             first = first + 16;
7944           printf ("pop {D%d", first);
7945           if (last)
7946             printf ("-D%d", first + last);
7947           printf ("}");
7948         }
7949       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7950         {
7951           unsigned int count = op & 0x07;
7952
7953           printf ("pop {D8");
7954           if (count)
7955             printf ("-D%d", 8 + count);
7956           printf ("}");
7957         }
7958       else if (op >= 0xc0 && op <= 0xc5)
7959         {
7960           unsigned int count = op & 0x07;
7961
7962           printf ("     pop {wR10");
7963           if (count)
7964             printf ("-wR%d", 10 + count);
7965           printf ("}");
7966         }
7967       else if (op == 0xc6)
7968         {
7969           unsigned int first, last;
7970
7971           GET_OP (op2);
7972           first = op2 >> 4;
7973           last = op2 & 0x0f;
7974           printf ("pop {wR%d", first);
7975           if (last)
7976             printf ("-wR%d", first + last);
7977           printf ("}");
7978         }
7979       else if (op == 0xc7)
7980         {
7981           GET_OP (op2);
7982           if (op2 == 0 || (op2 & 0xf0) != 0)
7983             printf (_("[Spare]"));
7984           else
7985             {
7986               unsigned int mask = op2 & 0x0f;
7987               int first = 1;
7988               int i;
7989
7990               printf ("pop {");
7991               for (i = 0; i < 4; i++)
7992                 if (mask & (1 << i))
7993                   {
7994                     if (first)
7995                       first = 0;
7996                     else
7997                       printf (", ");
7998                     printf ("wCGR%d", i);
7999                   }
8000               printf ("}");
8001             }
8002         }
8003       else
8004         printf (_("     [unsupported opcode]"));
8005       printf ("\n");
8006     }
8007 }
8008
8009 static void
8010 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8011                               unsigned int               word,
8012                               unsigned int               remaining,
8013                               unsigned int               more_words,
8014                               bfd_vma                    data_offset,
8015                               Elf_Internal_Shdr *        data_sec,
8016                               struct arm_section *       data_arm_sec)
8017 {
8018   struct absaddr addr;
8019
8020   /* Decode the unwinding instructions.  */
8021   while (1)
8022     {
8023       unsigned int op, op2;
8024
8025       ADVANCE;
8026       if (remaining == 0)
8027         break;
8028       remaining--;
8029       op = word >> 24;
8030       word <<= 8;
8031
8032       printf ("  0x%02x ", op);
8033
8034       if ((op & 0xc0) == 0x00)
8035         {
8036           int offset = ((op & 0x3f) << 3) + 8;
8037           printf ("     sp = sp + %d", offset);
8038         }
8039       else if ((op & 0xc0) == 0x80)
8040         {
8041           GET_OP (op2);
8042           if (op == 0x80 && op2 == 0)
8043             printf (_("Refuse to unwind"));
8044           else
8045             {
8046               unsigned int mask = ((op & 0x1f) << 8) | op2;
8047               if (op & 0x20)
8048                 printf ("pop compact {");
8049               else
8050                 printf ("pop {");
8051
8052               decode_tic6x_unwind_regmask (mask);
8053               printf("}");
8054             }
8055         }
8056       else if ((op & 0xf0) == 0xc0)
8057         {
8058           unsigned int reg;
8059           unsigned int nregs;
8060           unsigned int i;
8061           const char *name;
8062           struct
8063           {
8064               unsigned int offset;
8065               unsigned int reg;
8066           } regpos[16];
8067
8068           /* Scan entire instruction first so that GET_OP output is not
8069              interleaved with disassembly.  */
8070           nregs = 0;
8071           for (i = 0; nregs < (op & 0xf); i++)
8072             {
8073               GET_OP (op2);
8074               reg = op2 >> 4;
8075               if (reg != 0xf)
8076                 {
8077                   regpos[nregs].offset = i * 2;
8078                   regpos[nregs].reg = reg;
8079                   nregs++;
8080                 }
8081
8082               reg = op2 & 0xf;
8083               if (reg != 0xf)
8084                 {
8085                   regpos[nregs].offset = i * 2 + 1;
8086                   regpos[nregs].reg = reg;
8087                   nregs++;
8088                 }
8089             }
8090
8091           printf (_("pop frame {"));
8092           reg = nregs - 1;
8093           for (i = i * 2; i > 0; i--)
8094             {
8095               if (regpos[reg].offset == i - 1)
8096                 {
8097                   name = tic6x_unwind_regnames[regpos[reg].reg];
8098                   if (reg > 0)
8099                     reg--;
8100                 }
8101               else
8102                 name = _("[pad]");
8103
8104               fputs (name, stdout);
8105               if (i > 1)
8106                 printf (", ");
8107             }
8108
8109           printf ("}");
8110         }
8111       else if (op == 0xd0)
8112         printf ("     MOV FP, SP");
8113       else if (op == 0xd1)
8114         printf ("     __c6xabi_pop_rts");
8115       else if (op == 0xd2)
8116         {
8117           unsigned char buf[9];
8118           unsigned int i, len;
8119           unsigned long offset;
8120
8121           for (i = 0; i < sizeof (buf); i++)
8122             {
8123               GET_OP (buf[i]);
8124               if ((buf[i] & 0x80) == 0)
8125                 break;
8126             }
8127           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8128           if (i == sizeof (buf))
8129             {
8130               printf ("<corrupt sp adjust>\n");
8131               warn (_("Corrupt stack pointer adjustment detected\n"));
8132               return;
8133             }
8134
8135           offset = read_uleb128 (buf, &len, buf + i + 1);
8136           assert (len == i + 1);
8137           offset = offset * 8 + 0x408;
8138           printf (_("sp = sp + %ld"), offset);
8139         }
8140       else if ((op & 0xf0) == 0xe0)
8141         {
8142           if ((op & 0x0f) == 7)
8143             printf ("     RETURN");
8144           else
8145             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8146         }
8147       else
8148         {
8149           printf (_("     [unsupported opcode]"));
8150         }
8151       putchar ('\n');
8152     }
8153 }
8154
8155 static bfd_vma
8156 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8157 {
8158   bfd_vma offset;
8159
8160   offset = word & 0x7fffffff;
8161   if (offset & 0x40000000)
8162     offset |= ~ (bfd_vma) 0x7fffffff;
8163
8164   if (elf_header.e_machine == EM_TI_C6000)
8165     offset <<= 1;
8166
8167   return offset + where;
8168 }
8169
8170 static void
8171 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8172                    unsigned int               word,
8173                    unsigned int               remaining,
8174                    bfd_vma                    data_offset,
8175                    Elf_Internal_Shdr *        data_sec,
8176                    struct arm_section *       data_arm_sec)
8177 {
8178   int per_index;
8179   unsigned int more_words = 0;
8180   struct absaddr addr;
8181   bfd_vma sym_name = (bfd_vma) -1;
8182
8183   if (remaining == 0)
8184     {
8185       /* Fetch the first word.
8186          Note - when decoding an object file the address extracted
8187          here will always be 0.  So we also pass in the sym_name
8188          parameter so that we can find the symbol associated with
8189          the personality routine.  */
8190       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8191                                      & word, & addr, & sym_name))
8192         return;
8193
8194       remaining = 4;
8195     }
8196
8197   if ((word & 0x80000000) == 0)
8198     {
8199       /* Expand prel31 for personality routine.  */
8200       bfd_vma fn;
8201       const char *procname;
8202
8203       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8204       printf (_("  Personality routine: "));
8205       if (fn == 0
8206           && addr.section == SHN_UNDEF && addr.offset == 0
8207           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8208         {
8209           procname = aux->strtab + sym_name;
8210           print_vma (fn, PREFIX_HEX);
8211           if (procname)
8212             {
8213               fputs (" <", stdout);
8214               fputs (procname, stdout);
8215               fputc ('>', stdout);
8216             }
8217         }
8218       else
8219         procname = arm_print_vma_and_name (aux, fn, addr);
8220       fputc ('\n', stdout);
8221
8222       /* The GCC personality routines use the standard compact
8223          encoding, starting with one byte giving the number of
8224          words.  */
8225       if (procname != NULL
8226           && (const_strneq (procname, "__gcc_personality_v0")
8227               || const_strneq (procname, "__gxx_personality_v0")
8228               || const_strneq (procname, "__gcj_personality_v0")
8229               || const_strneq (procname, "__gnu_objc_personality_v0")))
8230         {
8231           remaining = 0;
8232           more_words = 1;
8233           ADVANCE;
8234           if (!remaining)
8235             {
8236               printf (_("  [Truncated data]\n"));
8237               return;
8238             }
8239           more_words = word >> 24;
8240           word <<= 8;
8241           remaining--;
8242           per_index = -1;
8243         }
8244       else
8245         return;
8246     }
8247   else
8248     {
8249       /* ARM EHABI Section 6.3:
8250
8251          An exception-handling table entry for the compact model looks like:
8252
8253            31 30-28 27-24 23-0
8254            -- ----- ----- ----
8255             1   0   index Data for personalityRoutine[index]    */
8256
8257       if (elf_header.e_machine == EM_ARM
8258           && (word & 0x70000000))
8259         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8260
8261       per_index = (word >> 24) & 0x7f;
8262       printf (_("  Compact model index: %d\n"), per_index);
8263       if (per_index == 0)
8264         {
8265           more_words = 0;
8266           word <<= 8;
8267           remaining--;
8268         }
8269       else if (per_index < 3)
8270         {
8271           more_words = (word >> 16) & 0xff;
8272           word <<= 16;
8273           remaining -= 2;
8274         }
8275     }
8276
8277   switch (elf_header.e_machine)
8278     {
8279     case EM_ARM:
8280       if (per_index < 3)
8281         {
8282           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8283                                       data_offset, data_sec, data_arm_sec);
8284         }
8285       else
8286         {
8287           warn (_("Unknown ARM compact model index encountered\n"));
8288           printf (_("  [reserved]\n"));
8289         }
8290       break;
8291
8292     case EM_TI_C6000:
8293       if (per_index < 3)
8294         {
8295           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8296                                         data_offset, data_sec, data_arm_sec);
8297         }
8298       else if (per_index < 5)
8299         {
8300           if (((word >> 17) & 0x7f) == 0x7f)
8301             printf (_("  Restore stack from frame pointer\n"));
8302           else
8303             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8304           printf (_("  Registers restored: "));
8305           if (per_index == 4)
8306             printf (" (compact) ");
8307           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8308           putchar ('\n');
8309           printf (_("  Return register: %s\n"),
8310                   tic6x_unwind_regnames[word & 0xf]);
8311         }
8312       else
8313         printf (_("  [reserved (%d)]\n"), per_index);
8314       break;
8315
8316     default:
8317       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8318              elf_header.e_machine);
8319     }
8320
8321   /* Decode the descriptors.  Not implemented.  */
8322 }
8323
8324 static void
8325 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8326 {
8327   struct arm_section exidx_arm_sec, extab_arm_sec;
8328   unsigned int i, exidx_len;
8329   unsigned long j, nfuns;
8330
8331   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8332   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8333   exidx_len = exidx_sec->sh_size / 8;
8334
8335   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8336   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8337     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8338       aux->funtab[nfuns++] = aux->symtab[j];
8339   aux->nfuns = nfuns;
8340   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8341
8342   for (i = 0; i < exidx_len; i++)
8343     {
8344       unsigned int exidx_fn, exidx_entry;
8345       struct absaddr fn_addr, entry_addr;
8346       bfd_vma fn;
8347
8348       fputc ('\n', stdout);
8349
8350       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8351                                      8 * i, & exidx_fn, & fn_addr, NULL)
8352           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8353                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8354         {
8355           free (aux->funtab);
8356           arm_free_section (& exidx_arm_sec);
8357           arm_free_section (& extab_arm_sec);
8358           return;
8359         }
8360
8361       /* ARM EHABI, Section 5:
8362          An index table entry consists of 2 words.
8363          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8364       if (exidx_fn & 0x80000000)
8365         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8366
8367       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8368
8369       arm_print_vma_and_name (aux, fn, fn_addr);
8370       fputs (": ", stdout);
8371
8372       if (exidx_entry == 1)
8373         {
8374           print_vma (exidx_entry, PREFIX_HEX);
8375           fputs (" [cantunwind]\n", stdout);
8376         }
8377       else if (exidx_entry & 0x80000000)
8378         {
8379           print_vma (exidx_entry, PREFIX_HEX);
8380           fputc ('\n', stdout);
8381           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8382         }
8383       else
8384         {
8385           bfd_vma table, table_offset = 0;
8386           Elf_Internal_Shdr *table_sec;
8387
8388           fputs ("@", stdout);
8389           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8390           print_vma (table, PREFIX_HEX);
8391           printf ("\n");
8392
8393           /* Locate the matching .ARM.extab.  */
8394           if (entry_addr.section != SHN_UNDEF
8395               && entry_addr.section < elf_header.e_shnum)
8396             {
8397               table_sec = section_headers + entry_addr.section;
8398               table_offset = entry_addr.offset;
8399               /* PR 18879 */
8400               if (table_offset > table_sec->sh_size
8401                   || ((bfd_signed_vma) table_offset) < 0)
8402                 {
8403                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8404                         (unsigned long) table_offset,
8405                         printable_section_name (table_sec));
8406                   continue;
8407                 }
8408             }
8409           else
8410             {
8411               table_sec = find_section_by_address (table);
8412               if (table_sec != NULL)
8413                 table_offset = table - table_sec->sh_addr;
8414             }
8415           if (table_sec == NULL)
8416             {
8417               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8418                     (unsigned long) table);
8419               continue;
8420             }
8421           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8422                              &extab_arm_sec);
8423         }
8424     }
8425
8426   printf ("\n");
8427
8428   free (aux->funtab);
8429   arm_free_section (&exidx_arm_sec);
8430   arm_free_section (&extab_arm_sec);
8431 }
8432
8433 /* Used for both ARM and C6X unwinding tables.  */
8434
8435 static void
8436 arm_process_unwind (FILE *file)
8437 {
8438   struct arm_unw_aux_info aux;
8439   Elf_Internal_Shdr *unwsec = NULL;
8440   Elf_Internal_Shdr *strsec;
8441   Elf_Internal_Shdr *sec;
8442   unsigned long i;
8443   unsigned int sec_type;
8444
8445   switch (elf_header.e_machine)
8446     {
8447     case EM_ARM:
8448       sec_type = SHT_ARM_EXIDX;
8449       break;
8450
8451     case EM_TI_C6000:
8452       sec_type = SHT_C6000_UNWIND;
8453       break;
8454
8455     default:
8456       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8457              elf_header.e_machine);
8458       return;
8459     }
8460
8461   if (string_table == NULL)
8462     return;
8463
8464   memset (& aux, 0, sizeof (aux));
8465   aux.file = file;
8466
8467   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8468     {
8469       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8470         {
8471           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8472
8473           strsec = section_headers + sec->sh_link;
8474
8475           /* PR binutils/17531 file: 011-12666-0.004.  */
8476           if (aux.strtab != NULL)
8477             {
8478               error (_("Multiple string tables found in file.\n"));
8479               free (aux.strtab);
8480             }
8481           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8482                                  1, strsec->sh_size, _("string table"));
8483           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8484         }
8485       else if (sec->sh_type == sec_type)
8486         unwsec = sec;
8487     }
8488
8489   if (unwsec == NULL)
8490     printf (_("\nThere are no unwind sections in this file.\n"));
8491   else
8492     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8493       {
8494         if (sec->sh_type == sec_type)
8495           {
8496             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8497                     printable_section_name (sec),
8498                     (unsigned long) sec->sh_offset,
8499                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8500
8501             dump_arm_unwind (&aux, sec);
8502           }
8503       }
8504
8505   if (aux.symtab)
8506     free (aux.symtab);
8507   if (aux.strtab)
8508     free ((char *) aux.strtab);
8509 }
8510
8511 static void
8512 process_unwind (FILE * file)
8513 {
8514   struct unwind_handler
8515   {
8516     int machtype;
8517     void (* handler)(FILE *);
8518   } handlers[] =
8519   {
8520     { EM_ARM, arm_process_unwind },
8521     { EM_IA_64, ia64_process_unwind },
8522     { EM_PARISC, hppa_process_unwind },
8523     { EM_TI_C6000, arm_process_unwind },
8524     { 0, 0 }
8525   };
8526   int i;
8527
8528   if (!do_unwind)
8529     return;
8530
8531   for (i = 0; handlers[i].handler != NULL; i++)
8532     if (elf_header.e_machine == handlers[i].machtype)
8533       {
8534         handlers[i].handler (file);
8535         return;
8536       }
8537
8538   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8539           get_machine_name (elf_header.e_machine));
8540 }
8541
8542 static void
8543 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8544 {
8545   switch (entry->d_tag)
8546     {
8547     case DT_MIPS_FLAGS:
8548       if (entry->d_un.d_val == 0)
8549         printf (_("NONE"));
8550       else
8551         {
8552           static const char * opts[] =
8553           {
8554             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8555             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8556             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8557             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8558             "RLD_ORDER_SAFE"
8559           };
8560           unsigned int cnt;
8561           int first = 1;
8562
8563           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8564             if (entry->d_un.d_val & (1 << cnt))
8565               {
8566                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8567                 first = 0;
8568               }
8569         }
8570       break;
8571
8572     case DT_MIPS_IVERSION:
8573       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8574         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8575       else
8576         {
8577           char buf[40];
8578           sprintf_vma (buf, entry->d_un.d_ptr);
8579           /* Note: coded this way so that there is a single string for translation.  */
8580           printf (_("<corrupt: %s>"), buf);
8581         }
8582       break;
8583
8584     case DT_MIPS_TIME_STAMP:
8585       {
8586         char timebuf[20];
8587         struct tm * tmp;
8588         time_t atime = entry->d_un.d_val;
8589
8590         tmp = gmtime (&atime);
8591         /* PR 17531: file: 6accc532.  */
8592         if (tmp == NULL)
8593           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8594         else
8595           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8596                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8597                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8598         printf (_("Time Stamp: %s"), timebuf);
8599       }
8600       break;
8601
8602     case DT_MIPS_RLD_VERSION:
8603     case DT_MIPS_LOCAL_GOTNO:
8604     case DT_MIPS_CONFLICTNO:
8605     case DT_MIPS_LIBLISTNO:
8606     case DT_MIPS_SYMTABNO:
8607     case DT_MIPS_UNREFEXTNO:
8608     case DT_MIPS_HIPAGENO:
8609     case DT_MIPS_DELTA_CLASS_NO:
8610     case DT_MIPS_DELTA_INSTANCE_NO:
8611     case DT_MIPS_DELTA_RELOC_NO:
8612     case DT_MIPS_DELTA_SYM_NO:
8613     case DT_MIPS_DELTA_CLASSSYM_NO:
8614     case DT_MIPS_COMPACT_SIZE:
8615       print_vma (entry->d_un.d_ptr, DEC);
8616       break;
8617
8618     default:
8619       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8620     }
8621     putchar ('\n');
8622 }
8623
8624 static void
8625 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8626 {
8627   switch (entry->d_tag)
8628     {
8629     case DT_HP_DLD_FLAGS:
8630       {
8631         static struct
8632         {
8633           long int bit;
8634           const char * str;
8635         }
8636         flags[] =
8637         {
8638           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8639           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8640           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8641           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8642           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8643           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8644           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8645           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8646           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8647           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8648           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8649           { DT_HP_GST, "HP_GST" },
8650           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8651           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8652           { DT_HP_NODELETE, "HP_NODELETE" },
8653           { DT_HP_GROUP, "HP_GROUP" },
8654           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8655         };
8656         int first = 1;
8657         size_t cnt;
8658         bfd_vma val = entry->d_un.d_val;
8659
8660         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8661           if (val & flags[cnt].bit)
8662             {
8663               if (! first)
8664                 putchar (' ');
8665               fputs (flags[cnt].str, stdout);
8666               first = 0;
8667               val ^= flags[cnt].bit;
8668             }
8669
8670         if (val != 0 || first)
8671           {
8672             if (! first)
8673               putchar (' ');
8674             print_vma (val, HEX);
8675           }
8676       }
8677       break;
8678
8679     default:
8680       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8681       break;
8682     }
8683   putchar ('\n');
8684 }
8685
8686 #ifdef BFD64
8687
8688 /* VMS vs Unix time offset and factor.  */
8689
8690 #define VMS_EPOCH_OFFSET 35067168000000000LL
8691 #define VMS_GRANULARITY_FACTOR 10000000
8692
8693 /* Display a VMS time in a human readable format.  */
8694
8695 static void
8696 print_vms_time (bfd_int64_t vmstime)
8697 {
8698   struct tm *tm;
8699   time_t unxtime;
8700
8701   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8702   tm = gmtime (&unxtime);
8703   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8704           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8705           tm->tm_hour, tm->tm_min, tm->tm_sec);
8706 }
8707 #endif /* BFD64 */
8708
8709 static void
8710 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8711 {
8712   switch (entry->d_tag)
8713     {
8714     case DT_IA_64_PLT_RESERVE:
8715       /* First 3 slots reserved.  */
8716       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8717       printf (" -- ");
8718       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8719       break;
8720
8721     case DT_IA_64_VMS_LINKTIME:
8722 #ifdef BFD64
8723       print_vms_time (entry->d_un.d_val);
8724 #endif
8725       break;
8726
8727     case DT_IA_64_VMS_LNKFLAGS:
8728       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8729       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8730         printf (" CALL_DEBUG");
8731       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8732         printf (" NOP0BUFS");
8733       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8734         printf (" P0IMAGE");
8735       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8736         printf (" MKTHREADS");
8737       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8738         printf (" UPCALLS");
8739       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8740         printf (" IMGSTA");
8741       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8742         printf (" INITIALIZE");
8743       if (entry->d_un.d_val & VMS_LF_MAIN)
8744         printf (" MAIN");
8745       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8746         printf (" EXE_INIT");
8747       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8748         printf (" TBK_IN_IMG");
8749       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8750         printf (" DBG_IN_IMG");
8751       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8752         printf (" TBK_IN_DSF");
8753       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8754         printf (" DBG_IN_DSF");
8755       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8756         printf (" SIGNATURES");
8757       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8758         printf (" REL_SEG_OFF");
8759       break;
8760
8761     default:
8762       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8763       break;
8764     }
8765   putchar ('\n');
8766 }
8767
8768 static int
8769 get_32bit_dynamic_section (FILE * file)
8770 {
8771   Elf32_External_Dyn * edyn;
8772   Elf32_External_Dyn * ext;
8773   Elf_Internal_Dyn * entry;
8774
8775   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8776                                           dynamic_size, _("dynamic section"));
8777   if (!edyn)
8778     return 0;
8779
8780   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8781      might not have the luxury of section headers.  Look for the DT_NULL
8782      terminator to determine the number of entries.  */
8783   for (ext = edyn, dynamic_nent = 0;
8784        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8785        ext++)
8786     {
8787       dynamic_nent++;
8788       if (BYTE_GET (ext->d_tag) == DT_NULL)
8789         break;
8790     }
8791
8792   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8793                                                   sizeof (* entry));
8794   if (dynamic_section == NULL)
8795     {
8796       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8797              (unsigned long) dynamic_nent);
8798       free (edyn);
8799       return 0;
8800     }
8801
8802   for (ext = edyn, entry = dynamic_section;
8803        entry < dynamic_section + dynamic_nent;
8804        ext++, entry++)
8805     {
8806       entry->d_tag      = BYTE_GET (ext->d_tag);
8807       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8808     }
8809
8810   free (edyn);
8811
8812   return 1;
8813 }
8814
8815 static int
8816 get_64bit_dynamic_section (FILE * file)
8817 {
8818   Elf64_External_Dyn * edyn;
8819   Elf64_External_Dyn * ext;
8820   Elf_Internal_Dyn * entry;
8821
8822   /* Read in the data.  */
8823   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8824                                           dynamic_size, _("dynamic section"));
8825   if (!edyn)
8826     return 0;
8827
8828   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8829      might not have the luxury of section headers.  Look for the DT_NULL
8830      terminator to determine the number of entries.  */
8831   for (ext = edyn, dynamic_nent = 0;
8832        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
8833        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8834        ext++)
8835     {
8836       dynamic_nent++;
8837       if (BYTE_GET (ext->d_tag) == DT_NULL)
8838         break;
8839     }
8840
8841   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8842                                                   sizeof (* entry));
8843   if (dynamic_section == NULL)
8844     {
8845       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8846              (unsigned long) dynamic_nent);
8847       free (edyn);
8848       return 0;
8849     }
8850
8851   /* Convert from external to internal formats.  */
8852   for (ext = edyn, entry = dynamic_section;
8853        entry < dynamic_section + dynamic_nent;
8854        ext++, entry++)
8855     {
8856       entry->d_tag      = BYTE_GET (ext->d_tag);
8857       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8858     }
8859
8860   free (edyn);
8861
8862   return 1;
8863 }
8864
8865 static void
8866 print_dynamic_flags (bfd_vma flags)
8867 {
8868   int first = 1;
8869
8870   while (flags)
8871     {
8872       bfd_vma flag;
8873
8874       flag = flags & - flags;
8875       flags &= ~ flag;
8876
8877       if (first)
8878         first = 0;
8879       else
8880         putc (' ', stdout);
8881
8882       switch (flag)
8883         {
8884         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8885         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8886         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8887         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8888         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8889         default:                fputs (_("unknown"), stdout); break;
8890         }
8891     }
8892   puts ("");
8893 }
8894
8895 /* Parse and display the contents of the dynamic section.  */
8896
8897 static int
8898 process_dynamic_section (FILE * file)
8899 {
8900   Elf_Internal_Dyn * entry;
8901
8902   if (dynamic_size == 0)
8903     {
8904       if (do_dynamic)
8905         printf (_("\nThere is no dynamic section in this file.\n"));
8906
8907       return 1;
8908     }
8909
8910   if (is_32bit_elf)
8911     {
8912       if (! get_32bit_dynamic_section (file))
8913         return 0;
8914     }
8915   else if (! get_64bit_dynamic_section (file))
8916     return 0;
8917
8918   /* Find the appropriate symbol table.  */
8919   if (dynamic_symbols == NULL)
8920     {
8921       for (entry = dynamic_section;
8922            entry < dynamic_section + dynamic_nent;
8923            ++entry)
8924         {
8925           Elf_Internal_Shdr section;
8926
8927           if (entry->d_tag != DT_SYMTAB)
8928             continue;
8929
8930           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8931
8932           /* Since we do not know how big the symbol table is,
8933              we default to reading in the entire file (!) and
8934              processing that.  This is overkill, I know, but it
8935              should work.  */
8936           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8937
8938           if (archive_file_offset != 0)
8939             section.sh_size = archive_file_size - section.sh_offset;
8940           else
8941             {
8942               if (fseek (file, 0, SEEK_END))
8943                 error (_("Unable to seek to end of file!\n"));
8944
8945               section.sh_size = ftell (file) - section.sh_offset;
8946             }
8947
8948           if (is_32bit_elf)
8949             section.sh_entsize = sizeof (Elf32_External_Sym);
8950           else
8951             section.sh_entsize = sizeof (Elf64_External_Sym);
8952           section.sh_name = string_table_length;
8953
8954           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8955           if (num_dynamic_syms < 1)
8956             {
8957               error (_("Unable to determine the number of symbols to load\n"));
8958               continue;
8959             }
8960         }
8961     }
8962
8963   /* Similarly find a string table.  */
8964   if (dynamic_strings == NULL)
8965     {
8966       for (entry = dynamic_section;
8967            entry < dynamic_section + dynamic_nent;
8968            ++entry)
8969         {
8970           unsigned long offset;
8971           long str_tab_len;
8972
8973           if (entry->d_tag != DT_STRTAB)
8974             continue;
8975
8976           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8977
8978           /* Since we do not know how big the string table is,
8979              we default to reading in the entire file (!) and
8980              processing that.  This is overkill, I know, but it
8981              should work.  */
8982
8983           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8984
8985           if (archive_file_offset != 0)
8986             str_tab_len = archive_file_size - offset;
8987           else
8988             {
8989               if (fseek (file, 0, SEEK_END))
8990                 error (_("Unable to seek to end of file\n"));
8991               str_tab_len = ftell (file) - offset;
8992             }
8993
8994           if (str_tab_len < 1)
8995             {
8996               error
8997                 (_("Unable to determine the length of the dynamic string table\n"));
8998               continue;
8999             }
9000
9001           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9002                                                str_tab_len,
9003                                                _("dynamic string table"));
9004           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9005           break;
9006         }
9007     }
9008
9009   /* And find the syminfo section if available.  */
9010   if (dynamic_syminfo == NULL)
9011     {
9012       unsigned long syminsz = 0;
9013
9014       for (entry = dynamic_section;
9015            entry < dynamic_section + dynamic_nent;
9016            ++entry)
9017         {
9018           if (entry->d_tag == DT_SYMINENT)
9019             {
9020               /* Note: these braces are necessary to avoid a syntax
9021                  error from the SunOS4 C compiler.  */
9022               /* PR binutils/17531: A corrupt file can trigger this test.
9023                  So do not use an assert, instead generate an error message.  */
9024               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9025                 error (_("Bad value (%d) for SYMINENT entry\n"),
9026                        (int) entry->d_un.d_val);
9027             }
9028           else if (entry->d_tag == DT_SYMINSZ)
9029             syminsz = entry->d_un.d_val;
9030           else if (entry->d_tag == DT_SYMINFO)
9031             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9032                                                       syminsz);
9033         }
9034
9035       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9036         {
9037           Elf_External_Syminfo * extsyminfo;
9038           Elf_External_Syminfo * extsym;
9039           Elf_Internal_Syminfo * syminfo;
9040
9041           /* There is a syminfo section.  Read the data.  */
9042           extsyminfo = (Elf_External_Syminfo *)
9043               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9044                         _("symbol information"));
9045           if (!extsyminfo)
9046             return 0;
9047
9048           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9049           if (dynamic_syminfo == NULL)
9050             {
9051               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9052                      (unsigned long) syminsz);
9053               return 0;
9054             }
9055
9056           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9057           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9058                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9059                ++syminfo, ++extsym)
9060             {
9061               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9062               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9063             }
9064
9065           free (extsyminfo);
9066         }
9067     }
9068
9069   if (do_dynamic && dynamic_addr)
9070     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9071             dynamic_addr, (unsigned long) dynamic_nent);
9072   if (do_dynamic)
9073     printf (_("  Tag        Type                         Name/Value\n"));
9074
9075   for (entry = dynamic_section;
9076        entry < dynamic_section + dynamic_nent;
9077        entry++)
9078     {
9079       if (do_dynamic)
9080         {
9081           const char * dtype;
9082
9083           putchar (' ');
9084           print_vma (entry->d_tag, FULL_HEX);
9085           dtype = get_dynamic_type (entry->d_tag);
9086           printf (" (%s)%*s", dtype,
9087                   ((is_32bit_elf ? 27 : 19)
9088                    - (int) strlen (dtype)),
9089                   " ");
9090         }
9091
9092       switch (entry->d_tag)
9093         {
9094         case DT_FLAGS:
9095           if (do_dynamic)
9096             print_dynamic_flags (entry->d_un.d_val);
9097           break;
9098
9099         case DT_AUXILIARY:
9100         case DT_FILTER:
9101         case DT_CONFIG:
9102         case DT_DEPAUDIT:
9103         case DT_AUDIT:
9104           if (do_dynamic)
9105             {
9106               switch (entry->d_tag)
9107                 {
9108                 case DT_AUXILIARY:
9109                   printf (_("Auxiliary library"));
9110                   break;
9111
9112                 case DT_FILTER:
9113                   printf (_("Filter library"));
9114                   break;
9115
9116                 case DT_CONFIG:
9117                   printf (_("Configuration file"));
9118                   break;
9119
9120                 case DT_DEPAUDIT:
9121                   printf (_("Dependency audit library"));
9122                   break;
9123
9124                 case DT_AUDIT:
9125                   printf (_("Audit library"));
9126                   break;
9127                 }
9128
9129               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9130                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9131               else
9132                 {
9133                   printf (": ");
9134                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9135                   putchar ('\n');
9136                 }
9137             }
9138           break;
9139
9140         case DT_FEATURE:
9141           if (do_dynamic)
9142             {
9143               printf (_("Flags:"));
9144
9145               if (entry->d_un.d_val == 0)
9146                 printf (_(" None\n"));
9147               else
9148                 {
9149                   unsigned long int val = entry->d_un.d_val;
9150
9151                   if (val & DTF_1_PARINIT)
9152                     {
9153                       printf (" PARINIT");
9154                       val ^= DTF_1_PARINIT;
9155                     }
9156                   if (val & DTF_1_CONFEXP)
9157                     {
9158                       printf (" CONFEXP");
9159                       val ^= DTF_1_CONFEXP;
9160                     }
9161                   if (val != 0)
9162                     printf (" %lx", val);
9163                   puts ("");
9164                 }
9165             }
9166           break;
9167
9168         case DT_POSFLAG_1:
9169           if (do_dynamic)
9170             {
9171               printf (_("Flags:"));
9172
9173               if (entry->d_un.d_val == 0)
9174                 printf (_(" None\n"));
9175               else
9176                 {
9177                   unsigned long int val = entry->d_un.d_val;
9178
9179                   if (val & DF_P1_LAZYLOAD)
9180                     {
9181                       printf (" LAZYLOAD");
9182                       val ^= DF_P1_LAZYLOAD;
9183                     }
9184                   if (val & DF_P1_GROUPPERM)
9185                     {
9186                       printf (" GROUPPERM");
9187                       val ^= DF_P1_GROUPPERM;
9188                     }
9189                   if (val != 0)
9190                     printf (" %lx", val);
9191                   puts ("");
9192                 }
9193             }
9194           break;
9195
9196         case DT_FLAGS_1:
9197           if (do_dynamic)
9198             {
9199               printf (_("Flags:"));
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_1_NOW)
9207                     {
9208                       printf (" NOW");
9209                       val ^= DF_1_NOW;
9210                     }
9211                   if (val & DF_1_GLOBAL)
9212                     {
9213                       printf (" GLOBAL");
9214                       val ^= DF_1_GLOBAL;
9215                     }
9216                   if (val & DF_1_GROUP)
9217                     {
9218                       printf (" GROUP");
9219                       val ^= DF_1_GROUP;
9220                     }
9221                   if (val & DF_1_NODELETE)
9222                     {
9223                       printf (" NODELETE");
9224                       val ^= DF_1_NODELETE;
9225                     }
9226                   if (val & DF_1_LOADFLTR)
9227                     {
9228                       printf (" LOADFLTR");
9229                       val ^= DF_1_LOADFLTR;
9230                     }
9231                   if (val & DF_1_INITFIRST)
9232                     {
9233                       printf (" INITFIRST");
9234                       val ^= DF_1_INITFIRST;
9235                     }
9236                   if (val & DF_1_NOOPEN)
9237                     {
9238                       printf (" NOOPEN");
9239                       val ^= DF_1_NOOPEN;
9240                     }
9241                   if (val & DF_1_ORIGIN)
9242                     {
9243                       printf (" ORIGIN");
9244                       val ^= DF_1_ORIGIN;
9245                     }
9246                   if (val & DF_1_DIRECT)
9247                     {
9248                       printf (" DIRECT");
9249                       val ^= DF_1_DIRECT;
9250                     }
9251                   if (val & DF_1_TRANS)
9252                     {
9253                       printf (" TRANS");
9254                       val ^= DF_1_TRANS;
9255                     }
9256                   if (val & DF_1_INTERPOSE)
9257                     {
9258                       printf (" INTERPOSE");
9259                       val ^= DF_1_INTERPOSE;
9260                     }
9261                   if (val & DF_1_NODEFLIB)
9262                     {
9263                       printf (" NODEFLIB");
9264                       val ^= DF_1_NODEFLIB;
9265                     }
9266                   if (val & DF_1_NODUMP)
9267                     {
9268                       printf (" NODUMP");
9269                       val ^= DF_1_NODUMP;
9270                     }
9271                   if (val & DF_1_CONFALT)
9272                     {
9273                       printf (" CONFALT");
9274                       val ^= DF_1_CONFALT;
9275                     }
9276                   if (val & DF_1_ENDFILTEE)
9277                     {
9278                       printf (" ENDFILTEE");
9279                       val ^= DF_1_ENDFILTEE;
9280                     }
9281                   if (val & DF_1_DISPRELDNE)
9282                     {
9283                       printf (" DISPRELDNE");
9284                       val ^= DF_1_DISPRELDNE;
9285                     }
9286                   if (val & DF_1_DISPRELPND)
9287                     {
9288                       printf (" DISPRELPND");
9289                       val ^= DF_1_DISPRELPND;
9290                     }
9291                   if (val & DF_1_NODIRECT)
9292                     {
9293                       printf (" NODIRECT");
9294                       val ^= DF_1_NODIRECT;
9295                     }
9296                   if (val & DF_1_IGNMULDEF)
9297                     {
9298                       printf (" IGNMULDEF");
9299                       val ^= DF_1_IGNMULDEF;
9300                     }
9301                   if (val & DF_1_NOKSYMS)
9302                     {
9303                       printf (" NOKSYMS");
9304                       val ^= DF_1_NOKSYMS;
9305                     }
9306                   if (val & DF_1_NOHDR)
9307                     {
9308                       printf (" NOHDR");
9309                       val ^= DF_1_NOHDR;
9310                     }
9311                   if (val & DF_1_EDITED)
9312                     {
9313                       printf (" EDITED");
9314                       val ^= DF_1_EDITED;
9315                     }
9316                   if (val & DF_1_NORELOC)
9317                     {
9318                       printf (" NORELOC");
9319                       val ^= DF_1_NORELOC;
9320                     }
9321                   if (val & DF_1_SYMINTPOSE)
9322                     {
9323                       printf (" SYMINTPOSE");
9324                       val ^= DF_1_SYMINTPOSE;
9325                     }
9326                   if (val & DF_1_GLOBAUDIT)
9327                     {
9328                       printf (" GLOBAUDIT");
9329                       val ^= DF_1_GLOBAUDIT;
9330                     }
9331                   if (val & DF_1_SINGLETON)
9332                     {
9333                       printf (" SINGLETON");
9334                       val ^= DF_1_SINGLETON;
9335                     }
9336                   if (val & DF_1_STUB)
9337                     {
9338                       printf (" STUB");
9339                       val ^= DF_1_STUB;
9340                     }
9341                   if (val & DF_1_PIE)
9342                     {
9343                       printf (" PIE");
9344                       val ^= DF_1_PIE;
9345                     }
9346                   if (val != 0)
9347                     printf (" %lx", val);
9348                   puts ("");
9349                 }
9350             }
9351           break;
9352
9353         case DT_PLTREL:
9354           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9355           if (do_dynamic)
9356             puts (get_dynamic_type (entry->d_un.d_val));
9357           break;
9358
9359         case DT_NULL    :
9360         case DT_NEEDED  :
9361         case DT_PLTGOT  :
9362         case DT_HASH    :
9363         case DT_STRTAB  :
9364         case DT_SYMTAB  :
9365         case DT_RELA    :
9366         case DT_INIT    :
9367         case DT_FINI    :
9368         case DT_SONAME  :
9369         case DT_RPATH   :
9370         case DT_SYMBOLIC:
9371         case DT_REL     :
9372         case DT_DEBUG   :
9373         case DT_TEXTREL :
9374         case DT_JMPREL  :
9375         case DT_RUNPATH :
9376           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9377
9378           if (do_dynamic)
9379             {
9380               char * name;
9381
9382               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9383                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9384               else
9385                 name = NULL;
9386
9387               if (name)
9388                 {
9389                   switch (entry->d_tag)
9390                     {
9391                     case DT_NEEDED:
9392                       printf (_("Shared library: [%s]"), name);
9393
9394                       if (streq (name, program_interpreter))
9395                         printf (_(" program interpreter"));
9396                       break;
9397
9398                     case DT_SONAME:
9399                       printf (_("Library soname: [%s]"), name);
9400                       break;
9401
9402                     case DT_RPATH:
9403                       printf (_("Library rpath: [%s]"), name);
9404                       break;
9405
9406                     case DT_RUNPATH:
9407                       printf (_("Library runpath: [%s]"), name);
9408                       break;
9409
9410                     default:
9411                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9412                       break;
9413                     }
9414                 }
9415               else
9416                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9417
9418               putchar ('\n');
9419             }
9420           break;
9421
9422         case DT_PLTRELSZ:
9423         case DT_RELASZ  :
9424         case DT_STRSZ   :
9425         case DT_RELSZ   :
9426         case DT_RELAENT :
9427         case DT_SYMENT  :
9428         case DT_RELENT  :
9429           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9430         case DT_PLTPADSZ:
9431         case DT_MOVEENT :
9432         case DT_MOVESZ  :
9433         case DT_INIT_ARRAYSZ:
9434         case DT_FINI_ARRAYSZ:
9435         case DT_GNU_CONFLICTSZ:
9436         case DT_GNU_LIBLISTSZ:
9437           if (do_dynamic)
9438             {
9439               print_vma (entry->d_un.d_val, UNSIGNED);
9440               printf (_(" (bytes)\n"));
9441             }
9442           break;
9443
9444         case DT_VERDEFNUM:
9445         case DT_VERNEEDNUM:
9446         case DT_RELACOUNT:
9447         case DT_RELCOUNT:
9448           if (do_dynamic)
9449             {
9450               print_vma (entry->d_un.d_val, UNSIGNED);
9451               putchar ('\n');
9452             }
9453           break;
9454
9455         case DT_SYMINSZ:
9456         case DT_SYMINENT:
9457         case DT_SYMINFO:
9458         case DT_USED:
9459         case DT_INIT_ARRAY:
9460         case DT_FINI_ARRAY:
9461           if (do_dynamic)
9462             {
9463               if (entry->d_tag == DT_USED
9464                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9465                 {
9466                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9467
9468                   if (*name)
9469                     {
9470                       printf (_("Not needed object: [%s]\n"), name);
9471                       break;
9472                     }
9473                 }
9474
9475               print_vma (entry->d_un.d_val, PREFIX_HEX);
9476               putchar ('\n');
9477             }
9478           break;
9479
9480         case DT_BIND_NOW:
9481           /* The value of this entry is ignored.  */
9482           if (do_dynamic)
9483             putchar ('\n');
9484           break;
9485
9486         case DT_GNU_PRELINKED:
9487           if (do_dynamic)
9488             {
9489               struct tm * tmp;
9490               time_t atime = entry->d_un.d_val;
9491
9492               tmp = gmtime (&atime);
9493               /* PR 17533 file: 041-1244816-0.004.  */
9494               if (tmp == NULL)
9495                 printf (_("<corrupt time val: %lx"),
9496                         (unsigned long) atime);
9497               else
9498                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9499                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9500                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9501
9502             }
9503           break;
9504
9505         case DT_GNU_HASH:
9506           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9507           if (do_dynamic)
9508             {
9509               print_vma (entry->d_un.d_val, PREFIX_HEX);
9510               putchar ('\n');
9511             }
9512           break;
9513
9514         default:
9515           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9516             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9517               entry->d_un.d_val;
9518
9519           if (do_dynamic)
9520             {
9521               switch (elf_header.e_machine)
9522                 {
9523                 case EM_MIPS:
9524                 case EM_MIPS_RS3_LE:
9525                   dynamic_section_mips_val (entry);
9526                   break;
9527                 case EM_PARISC:
9528                   dynamic_section_parisc_val (entry);
9529                   break;
9530                 case EM_IA_64:
9531                   dynamic_section_ia64_val (entry);
9532                   break;
9533                 default:
9534                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9535                   putchar ('\n');
9536                 }
9537             }
9538           break;
9539         }
9540     }
9541
9542   return 1;
9543 }
9544
9545 static char *
9546 get_ver_flags (unsigned int flags)
9547 {
9548   static char buff[32];
9549
9550   buff[0] = 0;
9551
9552   if (flags == 0)
9553     return _("none");
9554
9555   if (flags & VER_FLG_BASE)
9556     strcat (buff, "BASE ");
9557
9558   if (flags & VER_FLG_WEAK)
9559     {
9560       if (flags & VER_FLG_BASE)
9561         strcat (buff, "| ");
9562
9563       strcat (buff, "WEAK ");
9564     }
9565
9566   if (flags & VER_FLG_INFO)
9567     {
9568       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9569         strcat (buff, "| ");
9570
9571       strcat (buff, "INFO ");
9572     }
9573
9574   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9575     strcat (buff, _("| <unknown>"));
9576
9577   return buff;
9578 }
9579
9580 /* Display the contents of the version sections.  */
9581
9582 static int
9583 process_version_sections (FILE * file)
9584 {
9585   Elf_Internal_Shdr * section;
9586   unsigned i;
9587   int found = 0;
9588
9589   if (! do_version)
9590     return 1;
9591
9592   for (i = 0, section = section_headers;
9593        i < elf_header.e_shnum;
9594        i++, section++)
9595     {
9596       switch (section->sh_type)
9597         {
9598         case SHT_GNU_verdef:
9599           {
9600             Elf_External_Verdef * edefs;
9601             unsigned int idx;
9602             unsigned int cnt;
9603             char * endbuf;
9604
9605             found = 1;
9606
9607             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9608                     printable_section_name (section),
9609                     section->sh_info);
9610
9611             printf (_("  Addr: 0x"));
9612             printf_vma (section->sh_addr);
9613             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9614                     (unsigned long) section->sh_offset, section->sh_link,
9615                     printable_section_name_from_index (section->sh_link));
9616
9617             edefs = (Elf_External_Verdef *)
9618                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9619                           _("version definition section"));
9620             if (!edefs)
9621               break;
9622             endbuf = (char *) edefs + section->sh_size;
9623
9624             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9625               {
9626                 char * vstart;
9627                 Elf_External_Verdef * edef;
9628                 Elf_Internal_Verdef ent;
9629                 Elf_External_Verdaux * eaux;
9630                 Elf_Internal_Verdaux aux;
9631                 int j;
9632                 int isum;
9633
9634                 /* Check for very large indicies.  */
9635                 if (idx > (size_t) (endbuf - (char *) edefs))
9636                   break;
9637
9638                 vstart = ((char *) edefs) + idx;
9639                 if (vstart + sizeof (*edef) > endbuf)
9640                   break;
9641
9642                 edef = (Elf_External_Verdef *) vstart;
9643
9644                 ent.vd_version = BYTE_GET (edef->vd_version);
9645                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9646                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9647                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9648                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9649                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9650                 ent.vd_next    = BYTE_GET (edef->vd_next);
9651
9652                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9653                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9654
9655                 printf (_("  Index: %d  Cnt: %d  "),
9656                         ent.vd_ndx, ent.vd_cnt);
9657
9658                 /* Check for overflow.  */
9659                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9660                   break;
9661
9662                 vstart += ent.vd_aux;
9663
9664                 eaux = (Elf_External_Verdaux *) vstart;
9665
9666                 aux.vda_name = BYTE_GET (eaux->vda_name);
9667                 aux.vda_next = BYTE_GET (eaux->vda_next);
9668
9669                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9670                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9671                 else
9672                   printf (_("Name index: %ld\n"), aux.vda_name);
9673
9674                 isum = idx + ent.vd_aux;
9675
9676                 for (j = 1; j < ent.vd_cnt; j++)
9677                   {
9678                     /* Check for overflow.  */
9679                     if (aux.vda_next > (size_t) (endbuf - vstart))
9680                       break;
9681
9682                     isum   += aux.vda_next;
9683                     vstart += aux.vda_next;
9684
9685                     eaux = (Elf_External_Verdaux *) vstart;
9686                     if (vstart + sizeof (*eaux) > endbuf)
9687                       break;
9688
9689                     aux.vda_name = BYTE_GET (eaux->vda_name);
9690                     aux.vda_next = BYTE_GET (eaux->vda_next);
9691
9692                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9693                       printf (_("  %#06x: Parent %d: %s\n"),
9694                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9695                     else
9696                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9697                               isum, j, aux.vda_name);
9698                   }
9699
9700                 if (j < ent.vd_cnt)
9701                   printf (_("  Version def aux past end of section\n"));
9702
9703                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9704                 if (idx + ent.vd_next <= idx)
9705                   break;
9706
9707                 idx += ent.vd_next;
9708               }
9709
9710             if (cnt < section->sh_info)
9711               printf (_("  Version definition past end of section\n"));
9712
9713             free (edefs);
9714           }
9715           break;
9716
9717         case SHT_GNU_verneed:
9718           {
9719             Elf_External_Verneed * eneed;
9720             unsigned int idx;
9721             unsigned int cnt;
9722             char * endbuf;
9723
9724             found = 1;
9725
9726             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9727                     printable_section_name (section), section->sh_info);
9728
9729             printf (_(" Addr: 0x"));
9730             printf_vma (section->sh_addr);
9731             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9732                     (unsigned long) section->sh_offset, section->sh_link,
9733                     printable_section_name_from_index (section->sh_link));
9734
9735             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9736                                                        section->sh_offset, 1,
9737                                                        section->sh_size,
9738                                                        _("Version Needs section"));
9739             if (!eneed)
9740               break;
9741             endbuf = (char *) eneed + section->sh_size;
9742
9743             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9744               {
9745                 Elf_External_Verneed * entry;
9746                 Elf_Internal_Verneed ent;
9747                 int j;
9748                 int isum;
9749                 char * vstart;
9750
9751                 if (idx > (size_t) (endbuf - (char *) eneed))
9752                   break;
9753
9754                 vstart = ((char *) eneed) + idx;
9755                 if (vstart + sizeof (*entry) > endbuf)
9756                   break;
9757
9758                 entry = (Elf_External_Verneed *) vstart;
9759
9760                 ent.vn_version = BYTE_GET (entry->vn_version);
9761                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9762                 ent.vn_file    = BYTE_GET (entry->vn_file);
9763                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9764                 ent.vn_next    = BYTE_GET (entry->vn_next);
9765
9766                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9767
9768                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9769                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9770                 else
9771                   printf (_("  File: %lx"), ent.vn_file);
9772
9773                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9774
9775                 /* Check for overflow.  */
9776                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9777                   break;
9778                 vstart += ent.vn_aux;
9779
9780                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9781                   {
9782                     Elf_External_Vernaux * eaux;
9783                     Elf_Internal_Vernaux aux;
9784
9785                     if (vstart + sizeof (*eaux) > endbuf)
9786                       break;
9787                     eaux = (Elf_External_Vernaux *) vstart;
9788
9789                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9790                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9791                     aux.vna_other = BYTE_GET (eaux->vna_other);
9792                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9793                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9794
9795                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9796                       printf (_("  %#06x:   Name: %s"),
9797                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9798                     else
9799                       printf (_("  %#06x:   Name index: %lx"),
9800                               isum, aux.vna_name);
9801
9802                     printf (_("  Flags: %s  Version: %d\n"),
9803                             get_ver_flags (aux.vna_flags), aux.vna_other);
9804
9805                     /* Check for overflow.  */
9806                     if (aux.vna_next > (size_t) (endbuf - vstart)
9807                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9808                       {
9809                         warn (_("Invalid vna_next field of %lx\n"),
9810                               aux.vna_next);
9811                         j = ent.vn_cnt;
9812                         break;
9813                       }
9814                     isum   += aux.vna_next;
9815                     vstart += aux.vna_next;
9816                   }
9817
9818                 if (j < ent.vn_cnt)
9819                   warn (_("Missing Version Needs auxillary information\n"));
9820
9821                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9822                   {
9823                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9824                     cnt = section->sh_info;
9825                     break;
9826                   }
9827                 idx += ent.vn_next;
9828               }
9829
9830             if (cnt < section->sh_info)
9831               warn (_("Missing Version Needs information\n"));
9832
9833             free (eneed);
9834           }
9835           break;
9836
9837         case SHT_GNU_versym:
9838           {
9839             Elf_Internal_Shdr * link_section;
9840             size_t total;
9841             unsigned int cnt;
9842             unsigned char * edata;
9843             unsigned short * data;
9844             char * strtab;
9845             Elf_Internal_Sym * symbols;
9846             Elf_Internal_Shdr * string_sec;
9847             unsigned long num_syms;
9848             long off;
9849
9850             if (section->sh_link >= elf_header.e_shnum)
9851               break;
9852
9853             link_section = section_headers + section->sh_link;
9854             total = section->sh_size / sizeof (Elf_External_Versym);
9855
9856             if (link_section->sh_link >= elf_header.e_shnum)
9857               break;
9858
9859             found = 1;
9860
9861             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9862             if (symbols == NULL)
9863               break;
9864
9865             string_sec = section_headers + link_section->sh_link;
9866
9867             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9868                                         string_sec->sh_size,
9869                                         _("version string table"));
9870             if (!strtab)
9871               {
9872                 free (symbols);
9873                 break;
9874               }
9875
9876             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9877                     printable_section_name (section), (unsigned long) total);
9878
9879             printf (_(" Addr: "));
9880             printf_vma (section->sh_addr);
9881             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9882                     (unsigned long) section->sh_offset, section->sh_link,
9883                     printable_section_name (link_section));
9884
9885             off = offset_from_vma (file,
9886                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9887                                    total * sizeof (short));
9888             edata = (unsigned char *) get_data (NULL, file, off, total,
9889                                                 sizeof (short),
9890                                                 _("version symbol data"));
9891             if (!edata)
9892               {
9893                 free (strtab);
9894                 free (symbols);
9895                 break;
9896               }
9897
9898             data = (short unsigned int *) cmalloc (total, sizeof (short));
9899
9900             for (cnt = total; cnt --;)
9901               data[cnt] = byte_get (edata + cnt * sizeof (short),
9902                                     sizeof (short));
9903
9904             free (edata);
9905
9906             for (cnt = 0; cnt < total; cnt += 4)
9907               {
9908                 int j, nn;
9909                 char *name;
9910                 char *invalid = _("*invalid*");
9911
9912                 printf ("  %03x:", cnt);
9913
9914                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9915                   switch (data[cnt + j])
9916                     {
9917                     case 0:
9918                       fputs (_("   0 (*local*)    "), stdout);
9919                       break;
9920
9921                     case 1:
9922                       fputs (_("   1 (*global*)   "), stdout);
9923                       break;
9924
9925                     default:
9926                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9927                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9928
9929                       /* If this index value is greater than the size of the symbols
9930                          array, break to avoid an out-of-bounds read.  */
9931                       if ((unsigned long)(cnt + j) >= num_syms)
9932                         {
9933                           warn (_("invalid index into symbol array\n"));
9934                           break;
9935                         }
9936
9937                       name = NULL;
9938                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9939                         {
9940                           Elf_Internal_Verneed ivn;
9941                           unsigned long offset;
9942
9943                           offset = offset_from_vma
9944                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9945                              sizeof (Elf_External_Verneed));
9946
9947                           do
9948                             {
9949                               Elf_Internal_Vernaux ivna;
9950                               Elf_External_Verneed evn;
9951                               Elf_External_Vernaux evna;
9952                               unsigned long a_off;
9953
9954                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9955                                             _("version need")) == NULL)
9956                                 break;
9957
9958                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9959                               ivn.vn_next = BYTE_GET (evn.vn_next);
9960
9961                               a_off = offset + ivn.vn_aux;
9962
9963                               do
9964                                 {
9965                                   if (get_data (&evna, file, a_off, sizeof (evna),
9966                                                 1, _("version need aux (2)")) == NULL)
9967                                     {
9968                                       ivna.vna_next  = 0;
9969                                       ivna.vna_other = 0;
9970                                     }
9971                                   else
9972                                     {
9973                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9974                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9975                                     }
9976
9977                                   a_off += ivna.vna_next;
9978                                 }
9979                               while (ivna.vna_other != data[cnt + j]
9980                                      && ivna.vna_next != 0);
9981
9982                               if (ivna.vna_other == data[cnt + j])
9983                                 {
9984                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9985
9986                                   if (ivna.vna_name >= string_sec->sh_size)
9987                                     name = invalid;
9988                                   else
9989                                     name = strtab + ivna.vna_name;
9990                                   break;
9991                                 }
9992
9993                               offset += ivn.vn_next;
9994                             }
9995                           while (ivn.vn_next);
9996                         }
9997
9998                       if (data[cnt + j] != 0x8001
9999                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10000                         {
10001                           Elf_Internal_Verdef ivd;
10002                           Elf_External_Verdef evd;
10003                           unsigned long offset;
10004
10005                           offset = offset_from_vma
10006                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10007                              sizeof evd);
10008
10009                           do
10010                             {
10011                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10012                                             _("version def")) == NULL)
10013                                 {
10014                                   ivd.vd_next = 0;
10015                                   /* PR 17531: file: 046-1082287-0.004.  */
10016                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10017                                   break;
10018                                 }
10019                               else
10020                                 {
10021                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10022                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10023                                 }
10024
10025                               offset += ivd.vd_next;
10026                             }
10027                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10028                                  && ivd.vd_next != 0);
10029
10030                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10031                             {
10032                               Elf_External_Verdaux evda;
10033                               Elf_Internal_Verdaux ivda;
10034
10035                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10036
10037                               if (get_data (&evda, file,
10038                                             offset - ivd.vd_next + ivd.vd_aux,
10039                                             sizeof (evda), 1,
10040                                             _("version def aux")) == NULL)
10041                                 break;
10042
10043                               ivda.vda_name = BYTE_GET (evda.vda_name);
10044
10045                               if (ivda.vda_name >= string_sec->sh_size)
10046                                 name = invalid;
10047                               else if (name != NULL && name != invalid)
10048                                 name = _("*both*");
10049                               else
10050                                 name = strtab + ivda.vda_name;
10051                             }
10052                         }
10053                       if (name != NULL)
10054                         nn += printf ("(%s%-*s",
10055                                       name,
10056                                       12 - (int) strlen (name),
10057                                       ")");
10058
10059                       if (nn < 18)
10060                         printf ("%*c", 18 - nn, ' ');
10061                     }
10062
10063                 putchar ('\n');
10064               }
10065
10066             free (data);
10067             free (strtab);
10068             free (symbols);
10069           }
10070           break;
10071
10072         default:
10073           break;
10074         }
10075     }
10076
10077   if (! found)
10078     printf (_("\nNo version information found in this file.\n"));
10079
10080   return 1;
10081 }
10082
10083 static const char *
10084 get_symbol_binding (unsigned int binding)
10085 {
10086   static char buff[32];
10087
10088   switch (binding)
10089     {
10090     case STB_LOCAL:     return "LOCAL";
10091     case STB_GLOBAL:    return "GLOBAL";
10092     case STB_WEAK:      return "WEAK";
10093     default:
10094       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10095         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10096                   binding);
10097       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10098         {
10099           if (binding == STB_GNU_UNIQUE
10100               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10101                   /* GNU is still using the default value 0.  */
10102                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10103             return "UNIQUE";
10104           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10105         }
10106       else
10107         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10108       return buff;
10109     }
10110 }
10111
10112 static const char *
10113 get_symbol_type (unsigned int type)
10114 {
10115   static char buff[32];
10116
10117   switch (type)
10118     {
10119     case STT_NOTYPE:    return "NOTYPE";
10120     case STT_OBJECT:    return "OBJECT";
10121     case STT_FUNC:      return "FUNC";
10122     case STT_SECTION:   return "SECTION";
10123     case STT_FILE:      return "FILE";
10124     case STT_COMMON:    return "COMMON";
10125     case STT_TLS:       return "TLS";
10126     case STT_RELC:      return "RELC";
10127     case STT_SRELC:     return "SRELC";
10128     default:
10129       if (type >= STT_LOPROC && type <= STT_HIPROC)
10130         {
10131           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10132             return "THUMB_FUNC";
10133
10134           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10135             return "REGISTER";
10136
10137           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10138             return "PARISC_MILLI";
10139
10140           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10141         }
10142       else if (type >= STT_LOOS && type <= STT_HIOS)
10143         {
10144           if (elf_header.e_machine == EM_PARISC)
10145             {
10146               if (type == STT_HP_OPAQUE)
10147                 return "HP_OPAQUE";
10148               if (type == STT_HP_STUB)
10149                 return "HP_STUB";
10150             }
10151
10152           if (type == STT_GNU_IFUNC
10153               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10154                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10155                   /* GNU is still using the default value 0.  */
10156                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10157             return "IFUNC";
10158
10159           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10160         }
10161       else
10162         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10163       return buff;
10164     }
10165 }
10166
10167 static const char *
10168 get_symbol_visibility (unsigned int visibility)
10169 {
10170   switch (visibility)
10171     {
10172     case STV_DEFAULT:   return "DEFAULT";
10173     case STV_INTERNAL:  return "INTERNAL";
10174     case STV_HIDDEN:    return "HIDDEN";
10175     case STV_PROTECTED: return "PROTECTED";
10176     default:
10177       error (_("Unrecognized visibility value: %u"), visibility);
10178       return _("<unknown>");
10179     }
10180 }
10181
10182 static const char *
10183 get_mips_symbol_other (unsigned int other)
10184 {
10185   switch (other)
10186     {
10187     case STO_OPTIONAL:
10188       return "OPTIONAL";
10189     case STO_MIPS_PLT:
10190       return "MIPS PLT";
10191     case STO_MIPS_PIC:
10192       return "MIPS PIC";
10193     case STO_MICROMIPS:
10194       return "MICROMIPS";
10195     case STO_MICROMIPS | STO_MIPS_PIC:
10196       return "MICROMIPS, MIPS PIC";
10197     case STO_MIPS16:
10198       return "MIPS16";
10199     default:
10200       return NULL;
10201     }
10202 }
10203
10204 static const char *
10205 get_ia64_symbol_other (unsigned int other)
10206 {
10207   if (is_ia64_vms ())
10208     {
10209       static char res[32];
10210
10211       res[0] = 0;
10212
10213       /* Function types is for images and .STB files only.  */
10214       switch (elf_header.e_type)
10215         {
10216         case ET_DYN:
10217         case ET_EXEC:
10218           switch (VMS_ST_FUNC_TYPE (other))
10219             {
10220             case VMS_SFT_CODE_ADDR:
10221               strcat (res, " CA");
10222               break;
10223             case VMS_SFT_SYMV_IDX:
10224               strcat (res, " VEC");
10225               break;
10226             case VMS_SFT_FD:
10227               strcat (res, " FD");
10228               break;
10229             case VMS_SFT_RESERVE:
10230               strcat (res, " RSV");
10231               break;
10232             default:
10233               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10234                     VMS_ST_FUNC_TYPE (other));
10235               strcat (res, " <unknown>");
10236               break;
10237             }
10238           break;
10239         default:
10240           break;
10241         }
10242       switch (VMS_ST_LINKAGE (other))
10243         {
10244         case VMS_STL_IGNORE:
10245           strcat (res, " IGN");
10246           break;
10247         case VMS_STL_RESERVE:
10248           strcat (res, " RSV");
10249           break;
10250         case VMS_STL_STD:
10251           strcat (res, " STD");
10252           break;
10253         case VMS_STL_LNK:
10254           strcat (res, " LNK");
10255           break;
10256         default:
10257           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10258                 VMS_ST_LINKAGE (other));
10259           strcat (res, " <unknown>");
10260           break;
10261         }
10262
10263       if (res[0] != 0)
10264         return res + 1;
10265       else
10266         return res;
10267     }
10268   return NULL;
10269 }
10270
10271 static const char *
10272 get_ppc64_symbol_other (unsigned int other)
10273 {
10274   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10275     {
10276       static char buf[32];
10277       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10278                 PPC64_LOCAL_ENTRY_OFFSET (other));
10279       return buf;
10280     }
10281   return NULL;
10282 }
10283
10284 static const char *
10285 get_symbol_other (unsigned int other)
10286 {
10287   const char * result = NULL;
10288   static char buff [32];
10289
10290   if (other == 0)
10291     return "";
10292
10293   switch (elf_header.e_machine)
10294     {
10295     case EM_MIPS:
10296       result = get_mips_symbol_other (other);
10297       break;
10298     case EM_IA_64:
10299       result = get_ia64_symbol_other (other);
10300       break;
10301     case EM_PPC64:
10302       result = get_ppc64_symbol_other (other);
10303       break;
10304     default:
10305       break;
10306     }
10307
10308   if (result)
10309     return result;
10310
10311   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10312   return buff;
10313 }
10314
10315 static const char *
10316 get_symbol_index_type (unsigned int type)
10317 {
10318   static char buff[32];
10319
10320   switch (type)
10321     {
10322     case SHN_UNDEF:     return "UND";
10323     case SHN_ABS:       return "ABS";
10324     case SHN_COMMON:    return "COM";
10325     default:
10326       if (type == SHN_IA_64_ANSI_COMMON
10327           && elf_header.e_machine == EM_IA_64
10328           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10329         return "ANSI_COM";
10330       else if ((elf_header.e_machine == EM_X86_64
10331                 || elf_header.e_machine == EM_L1OM
10332                 || elf_header.e_machine == EM_K1OM)
10333                && type == SHN_X86_64_LCOMMON)
10334         return "LARGE_COM";
10335       else if ((type == SHN_MIPS_SCOMMON
10336                 && elf_header.e_machine == EM_MIPS)
10337                || (type == SHN_TIC6X_SCOMMON
10338                    && elf_header.e_machine == EM_TI_C6000))
10339         return "SCOM";
10340       else if (type == SHN_MIPS_SUNDEFINED
10341                && elf_header.e_machine == EM_MIPS)
10342         return "SUND";
10343       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10344         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10345       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10346         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10347       else if (type >= SHN_LORESERVE)
10348         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10349       else if (type >= elf_header.e_shnum)
10350         sprintf (buff, _("bad section index[%3d]"), type);
10351       else
10352         sprintf (buff, "%3d", type);
10353       break;
10354     }
10355
10356   return buff;
10357 }
10358
10359 static bfd_vma *
10360 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10361 {
10362   unsigned char * e_data;
10363   bfd_vma * i_data;
10364
10365   /* If the size_t type is smaller than the bfd_size_type, eg because
10366      you are building a 32-bit tool on a 64-bit host, then make sure
10367      that when (number) is cast to (size_t) no information is lost.  */
10368   if (sizeof (size_t) < sizeof (bfd_size_type)
10369       && (bfd_size_type) ((size_t) number) != number)
10370     {
10371       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10372              (unsigned long long) number, ent_size);
10373       return NULL;
10374     }
10375
10376   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10377      attempting to allocate memory when the read is bound to fail.  */
10378   if (ent_size * number > current_file_size)
10379     {
10380       error (_("Invalid number of dynamic entries: %llu\n"),
10381              (unsigned long long) number);
10382       return NULL;
10383     }
10384
10385   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10386   if (e_data == NULL)
10387     {
10388       error (_("Out of memory reading %llu dynamic entries\n"),
10389              (unsigned long long) number);
10390       return NULL;
10391     }
10392
10393   if (fread (e_data, ent_size, (size_t) number, file) != number)
10394     {
10395       error (_("Unable to read in %llu bytes of dynamic data\n"),
10396              (unsigned long long) (number * ent_size));
10397       free (e_data);
10398       return NULL;
10399     }
10400
10401   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10402   if (i_data == NULL)
10403     {
10404       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10405              (unsigned long long) number);
10406       free (e_data);
10407       return NULL;
10408     }
10409
10410   while (number--)
10411     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10412
10413   free (e_data);
10414
10415   return i_data;
10416 }
10417
10418 static void
10419 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10420 {
10421   Elf_Internal_Sym * psym;
10422   int n;
10423
10424   n = print_vma (si, DEC_5);
10425   if (n < 5)
10426     fputs (&"     "[n], stdout);
10427   printf (" %3lu: ", hn);
10428
10429   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10430     {
10431       printf (_("<No info available for dynamic symbol number %lu>\n"),
10432               (unsigned long) si);
10433       return;
10434     }
10435
10436   psym = dynamic_symbols + si;
10437   print_vma (psym->st_value, LONG_HEX);
10438   putchar (' ');
10439   print_vma (psym->st_size, DEC_5);
10440
10441   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10442   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10443   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10444   /* Check to see if any other bits in the st_other field are set.
10445      Note - displaying this information disrupts the layout of the
10446      table being generated, but for the moment this case is very
10447      rare.  */
10448   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10449     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10450   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10451   if (VALID_DYNAMIC_NAME (psym->st_name))
10452     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10453   else
10454     printf (_(" <corrupt: %14ld>"), psym->st_name);
10455   putchar ('\n');
10456 }
10457
10458 static const char *
10459 get_symbol_version_string (FILE *file, int is_dynsym,
10460                            const char *strtab,
10461                            unsigned long int strtab_size,
10462                            unsigned int si, Elf_Internal_Sym *psym,
10463                            enum versioned_symbol_info *sym_info,
10464                            unsigned short *vna_other)
10465 {
10466   unsigned char data[2];
10467   unsigned short vers_data;
10468   unsigned long offset;
10469
10470   if (!is_dynsym
10471       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10472     return NULL;
10473
10474   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10475                             sizeof data + si * sizeof (vers_data));
10476
10477   if (get_data (&data, file, offset + si * sizeof (vers_data),
10478                 sizeof (data), 1, _("version data")) == NULL)
10479     return NULL;
10480
10481   vers_data = byte_get (data, 2);
10482
10483   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10484     return NULL;
10485
10486   /* Usually we'd only see verdef for defined symbols, and verneed for
10487      undefined symbols.  However, symbols defined by the linker in
10488      .dynbss for variables copied from a shared library in order to
10489      avoid text relocations are defined yet have verneed.  We could
10490      use a heuristic to detect the special case, for example, check
10491      for verneed first on symbols defined in SHT_NOBITS sections, but
10492      it is simpler and more reliable to just look for both verdef and
10493      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
10494
10495   if (psym->st_shndx != SHN_UNDEF
10496       && vers_data != 0x8001
10497       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10498     {
10499       Elf_Internal_Verdef ivd;
10500       Elf_Internal_Verdaux ivda;
10501       Elf_External_Verdaux evda;
10502       unsigned long off;
10503
10504       off = offset_from_vma (file,
10505                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10506                              sizeof (Elf_External_Verdef));
10507
10508       do
10509         {
10510           Elf_External_Verdef evd;
10511
10512           if (get_data (&evd, file, off, sizeof (evd), 1,
10513                         _("version def")) == NULL)
10514             {
10515               ivd.vd_ndx = 0;
10516               ivd.vd_aux = 0;
10517               ivd.vd_next = 0;
10518             }
10519           else
10520             {
10521               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10522               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10523               ivd.vd_next = BYTE_GET (evd.vd_next);
10524             }
10525
10526           off += ivd.vd_next;
10527         }
10528       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10529
10530       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10531         {
10532           off -= ivd.vd_next;
10533           off += ivd.vd_aux;
10534
10535           if (get_data (&evda, file, off, sizeof (evda), 1,
10536                         _("version def aux")) != NULL)
10537             {
10538               ivda.vda_name = BYTE_GET (evda.vda_name);
10539
10540               if (psym->st_name != ivda.vda_name)
10541                 {
10542                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10543                                ? symbol_hidden : symbol_public);
10544                   return (ivda.vda_name < strtab_size
10545                           ? strtab + ivda.vda_name : _("<corrupt>"));
10546                 }
10547             }
10548         }
10549     }
10550
10551   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10552     {
10553       Elf_External_Verneed evn;
10554       Elf_Internal_Verneed ivn;
10555       Elf_Internal_Vernaux ivna;
10556
10557       offset = offset_from_vma (file,
10558                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10559                                 sizeof evn);
10560       do
10561         {
10562           unsigned long vna_off;
10563
10564           if (get_data (&evn, file, offset, sizeof (evn), 1,
10565                         _("version need")) == NULL)
10566             {
10567               ivna.vna_next = 0;
10568               ivna.vna_other = 0;
10569               ivna.vna_name = 0;
10570               break;
10571             }
10572
10573           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10574           ivn.vn_next = BYTE_GET (evn.vn_next);
10575
10576           vna_off = offset + ivn.vn_aux;
10577
10578           do
10579             {
10580               Elf_External_Vernaux evna;
10581
10582               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10583                             _("version need aux (3)")) == NULL)
10584                 {
10585                   ivna.vna_next = 0;
10586                   ivna.vna_other = 0;
10587                   ivna.vna_name = 0;
10588                 }
10589               else
10590                 {
10591                   ivna.vna_other = BYTE_GET (evna.vna_other);
10592                   ivna.vna_next  = BYTE_GET (evna.vna_next);
10593                   ivna.vna_name  = BYTE_GET (evna.vna_name);
10594                 }
10595
10596               vna_off += ivna.vna_next;
10597             }
10598           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
10599
10600           if (ivna.vna_other == vers_data)
10601             break;
10602
10603           offset += ivn.vn_next;
10604         }
10605       while (ivn.vn_next != 0);
10606
10607       if (ivna.vna_other == vers_data)
10608         {
10609           *sym_info = symbol_undefined;
10610           *vna_other = ivna.vna_other;
10611           return (ivna.vna_name < strtab_size
10612                   ? strtab + ivna.vna_name : _("<corrupt>"));
10613         }
10614     }
10615   return NULL;
10616 }
10617
10618 /* Dump the symbol table.  */
10619 static int
10620 process_symbol_table (FILE * file)
10621 {
10622   Elf_Internal_Shdr * section;
10623   bfd_size_type nbuckets = 0;
10624   bfd_size_type nchains = 0;
10625   bfd_vma * buckets = NULL;
10626   bfd_vma * chains = NULL;
10627   bfd_vma ngnubuckets = 0;
10628   bfd_vma * gnubuckets = NULL;
10629   bfd_vma * gnuchains = NULL;
10630   bfd_vma gnusymidx = 0;
10631   bfd_size_type ngnuchains = 0;
10632
10633   if (!do_syms && !do_dyn_syms && !do_histogram)
10634     return 1;
10635
10636   if (dynamic_info[DT_HASH]
10637       && (do_histogram
10638           || (do_using_dynamic
10639               && !do_dyn_syms
10640               && dynamic_strings != NULL)))
10641     {
10642       unsigned char nb[8];
10643       unsigned char nc[8];
10644       unsigned int hash_ent_size = 4;
10645
10646       if ((elf_header.e_machine == EM_ALPHA
10647            || elf_header.e_machine == EM_S390
10648            || elf_header.e_machine == EM_S390_OLD)
10649           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10650         hash_ent_size = 8;
10651
10652       if (fseek (file,
10653                  (archive_file_offset
10654                   + offset_from_vma (file, dynamic_info[DT_HASH],
10655                                      sizeof nb + sizeof nc)),
10656                  SEEK_SET))
10657         {
10658           error (_("Unable to seek to start of dynamic information\n"));
10659           goto no_hash;
10660         }
10661
10662       if (fread (nb, hash_ent_size, 1, file) != 1)
10663         {
10664           error (_("Failed to read in number of buckets\n"));
10665           goto no_hash;
10666         }
10667
10668       if (fread (nc, hash_ent_size, 1, file) != 1)
10669         {
10670           error (_("Failed to read in number of chains\n"));
10671           goto no_hash;
10672         }
10673
10674       nbuckets = byte_get (nb, hash_ent_size);
10675       nchains  = byte_get (nc, hash_ent_size);
10676
10677       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10678       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10679
10680     no_hash:
10681       if (buckets == NULL || chains == NULL)
10682         {
10683           if (do_using_dynamic)
10684             return 0;
10685           free (buckets);
10686           free (chains);
10687           buckets = NULL;
10688           chains = NULL;
10689           nbuckets = 0;
10690           nchains = 0;
10691         }
10692     }
10693
10694   if (dynamic_info_DT_GNU_HASH
10695       && (do_histogram
10696           || (do_using_dynamic
10697               && !do_dyn_syms
10698               && dynamic_strings != NULL)))
10699     {
10700       unsigned char nb[16];
10701       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10702       bfd_vma buckets_vma;
10703
10704       if (fseek (file,
10705                  (archive_file_offset
10706                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10707                                      sizeof nb)),
10708                  SEEK_SET))
10709         {
10710           error (_("Unable to seek to start of dynamic information\n"));
10711           goto no_gnu_hash;
10712         }
10713
10714       if (fread (nb, 16, 1, file) != 1)
10715         {
10716           error (_("Failed to read in number of buckets\n"));
10717           goto no_gnu_hash;
10718         }
10719
10720       ngnubuckets = byte_get (nb, 4);
10721       gnusymidx = byte_get (nb + 4, 4);
10722       bitmaskwords = byte_get (nb + 8, 4);
10723       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10724       if (is_32bit_elf)
10725         buckets_vma += bitmaskwords * 4;
10726       else
10727         buckets_vma += bitmaskwords * 8;
10728
10729       if (fseek (file,
10730                  (archive_file_offset
10731                   + offset_from_vma (file, buckets_vma, 4)),
10732                  SEEK_SET))
10733         {
10734           error (_("Unable to seek to start of dynamic information\n"));
10735           goto no_gnu_hash;
10736         }
10737
10738       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10739
10740       if (gnubuckets == NULL)
10741         goto no_gnu_hash;
10742
10743       for (i = 0; i < ngnubuckets; i++)
10744         if (gnubuckets[i] != 0)
10745           {
10746             if (gnubuckets[i] < gnusymidx)
10747               return 0;
10748
10749             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10750               maxchain = gnubuckets[i];
10751           }
10752
10753       if (maxchain == 0xffffffff)
10754         goto no_gnu_hash;
10755
10756       maxchain -= gnusymidx;
10757
10758       if (fseek (file,
10759                  (archive_file_offset
10760                   + offset_from_vma (file, buckets_vma
10761                                            + 4 * (ngnubuckets + maxchain), 4)),
10762                  SEEK_SET))
10763         {
10764           error (_("Unable to seek to start of dynamic information\n"));
10765           goto no_gnu_hash;
10766         }
10767
10768       do
10769         {
10770           if (fread (nb, 4, 1, file) != 1)
10771             {
10772               error (_("Failed to determine last chain length\n"));
10773               goto no_gnu_hash;
10774             }
10775
10776           if (maxchain + 1 == 0)
10777             goto no_gnu_hash;
10778
10779           ++maxchain;
10780         }
10781       while ((byte_get (nb, 4) & 1) == 0);
10782
10783       if (fseek (file,
10784                  (archive_file_offset
10785                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10786                  SEEK_SET))
10787         {
10788           error (_("Unable to seek to start of dynamic information\n"));
10789           goto no_gnu_hash;
10790         }
10791
10792       gnuchains = get_dynamic_data (file, maxchain, 4);
10793       ngnuchains = maxchain;
10794
10795     no_gnu_hash:
10796       if (gnuchains == NULL)
10797         {
10798           free (gnubuckets);
10799           gnubuckets = NULL;
10800           ngnubuckets = 0;
10801           if (do_using_dynamic)
10802             return 0;
10803         }
10804     }
10805
10806   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10807       && do_syms
10808       && do_using_dynamic
10809       && dynamic_strings != NULL
10810       && dynamic_symbols != NULL)
10811     {
10812       unsigned long hn;
10813
10814       if (dynamic_info[DT_HASH])
10815         {
10816           bfd_vma si;
10817
10818           printf (_("\nSymbol table for image:\n"));
10819           if (is_32bit_elf)
10820             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10821           else
10822             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10823
10824           for (hn = 0; hn < nbuckets; hn++)
10825             {
10826               if (! buckets[hn])
10827                 continue;
10828
10829               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10830                 print_dynamic_symbol (si, hn);
10831             }
10832         }
10833
10834       if (dynamic_info_DT_GNU_HASH)
10835         {
10836           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10837           if (is_32bit_elf)
10838             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10839           else
10840             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10841
10842           for (hn = 0; hn < ngnubuckets; ++hn)
10843             if (gnubuckets[hn] != 0)
10844               {
10845                 bfd_vma si = gnubuckets[hn];
10846                 bfd_vma off = si - gnusymidx;
10847
10848                 do
10849                   {
10850                     print_dynamic_symbol (si, hn);
10851                     si++;
10852                   }
10853                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10854               }
10855         }
10856     }
10857   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10858            && section_headers != NULL)
10859     {
10860       unsigned int i;
10861
10862       for (i = 0, section = section_headers;
10863            i < elf_header.e_shnum;
10864            i++, section++)
10865         {
10866           unsigned int si;
10867           char * strtab = NULL;
10868           unsigned long int strtab_size = 0;
10869           Elf_Internal_Sym * symtab;
10870           Elf_Internal_Sym * psym;
10871           unsigned long num_syms;
10872
10873           if ((section->sh_type != SHT_SYMTAB
10874                && section->sh_type != SHT_DYNSYM)
10875               || (!do_syms
10876                   && section->sh_type == SHT_SYMTAB))
10877             continue;
10878
10879           if (section->sh_entsize == 0)
10880             {
10881               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10882                       printable_section_name (section));
10883               continue;
10884             }
10885
10886           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10887                   printable_section_name (section),
10888                   (unsigned long) (section->sh_size / section->sh_entsize));
10889
10890           if (is_32bit_elf)
10891             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10892           else
10893             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10894
10895           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10896           if (symtab == NULL)
10897             continue;
10898
10899           if (section->sh_link == elf_header.e_shstrndx)
10900             {
10901               strtab = string_table;
10902               strtab_size = string_table_length;
10903             }
10904           else if (section->sh_link < elf_header.e_shnum)
10905             {
10906               Elf_Internal_Shdr * string_sec;
10907
10908               string_sec = section_headers + section->sh_link;
10909
10910               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10911                                           1, string_sec->sh_size,
10912                                           _("string table"));
10913               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10914             }
10915
10916           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10917             {
10918               const char *version_string;
10919               enum versioned_symbol_info sym_info;
10920               unsigned short vna_other;
10921
10922               printf ("%6d: ", si);
10923               print_vma (psym->st_value, LONG_HEX);
10924               putchar (' ');
10925               print_vma (psym->st_size, DEC_5);
10926               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10927               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10928               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10929               /* Check to see if any other bits in the st_other field are set.
10930                  Note - displaying this information disrupts the layout of the
10931                  table being generated, but for the moment this case is very rare.  */
10932               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10933                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10934               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10935               print_symbol (25, psym->st_name < strtab_size
10936                             ? strtab + psym->st_name : _("<corrupt>"));
10937
10938               version_string
10939                 = get_symbol_version_string (file,
10940                                              section->sh_type == SHT_DYNSYM,
10941                                              strtab, strtab_size, si,
10942                                              psym, &sym_info, &vna_other);
10943               if (version_string)
10944                 {
10945                   if (sym_info == symbol_undefined)
10946                     printf ("@%s (%d)", version_string, vna_other);
10947                   else
10948                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10949                             version_string);
10950                 }
10951
10952               putchar ('\n');
10953             }
10954
10955           free (symtab);
10956           if (strtab != string_table)
10957             free (strtab);
10958         }
10959     }
10960   else if (do_syms)
10961     printf
10962       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10963
10964   if (do_histogram && buckets != NULL)
10965     {
10966       unsigned long * lengths;
10967       unsigned long * counts;
10968       unsigned long hn;
10969       bfd_vma si;
10970       unsigned long maxlength = 0;
10971       unsigned long nzero_counts = 0;
10972       unsigned long nsyms = 0;
10973       unsigned long chained;
10974
10975       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10976               (unsigned long) nbuckets);
10977
10978       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10979       if (lengths == NULL)
10980         {
10981           error (_("Out of memory allocating space for histogram buckets\n"));
10982           return 0;
10983         }
10984
10985       printf (_(" Length  Number     %% of total  Coverage\n"));
10986       for (hn = 0; hn < nbuckets; ++hn)
10987         {
10988           for (si = buckets[hn], chained = 0;
10989                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10990                si = chains[si], ++chained)
10991             {
10992               ++nsyms;
10993               if (maxlength < ++lengths[hn])
10994                 ++maxlength;
10995             }
10996
10997             /* PR binutils/17531: A corrupt binary could contain broken
10998                histogram data.  Do not go into an infinite loop trying
10999                to process it.  */
11000             if (chained > nchains)
11001               {
11002                 error (_("histogram chain is corrupt\n"));
11003                 break;
11004               }
11005         }
11006
11007       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11008       if (counts == NULL)
11009         {
11010           free (lengths);
11011           error (_("Out of memory allocating space for histogram counts\n"));
11012           return 0;
11013         }
11014
11015       for (hn = 0; hn < nbuckets; ++hn)
11016         ++counts[lengths[hn]];
11017
11018       if (nbuckets > 0)
11019         {
11020           unsigned long i;
11021           printf ("      0  %-10lu (%5.1f%%)\n",
11022                   counts[0], (counts[0] * 100.0) / nbuckets);
11023           for (i = 1; i <= maxlength; ++i)
11024             {
11025               nzero_counts += counts[i] * i;
11026               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11027                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11028                       (nzero_counts * 100.0) / nsyms);
11029             }
11030         }
11031
11032       free (counts);
11033       free (lengths);
11034     }
11035
11036   if (buckets != NULL)
11037     {
11038       free (buckets);
11039       free (chains);
11040     }
11041
11042   if (do_histogram && gnubuckets != NULL)
11043     {
11044       unsigned long * lengths;
11045       unsigned long * counts;
11046       unsigned long hn;
11047       unsigned long maxlength = 0;
11048       unsigned long nzero_counts = 0;
11049       unsigned long nsyms = 0;
11050
11051       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11052               (unsigned long) ngnubuckets);
11053
11054       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11055       if (lengths == NULL)
11056         {
11057           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11058           return 0;
11059         }
11060
11061       printf (_(" Length  Number     %% of total  Coverage\n"));
11062
11063       for (hn = 0; hn < ngnubuckets; ++hn)
11064         if (gnubuckets[hn] != 0)
11065           {
11066             bfd_vma off, length = 1;
11067
11068             for (off = gnubuckets[hn] - gnusymidx;
11069                  /* PR 17531 file: 010-77222-0.004.  */
11070                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11071                  ++off)
11072               ++length;
11073             lengths[hn] = length;
11074             if (length > maxlength)
11075               maxlength = length;
11076             nsyms += length;
11077           }
11078
11079       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11080       if (counts == NULL)
11081         {
11082           free (lengths);
11083           error (_("Out of memory allocating space for gnu histogram counts\n"));
11084           return 0;
11085         }
11086
11087       for (hn = 0; hn < ngnubuckets; ++hn)
11088         ++counts[lengths[hn]];
11089
11090       if (ngnubuckets > 0)
11091         {
11092           unsigned long j;
11093           printf ("      0  %-10lu (%5.1f%%)\n",
11094                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11095           for (j = 1; j <= maxlength; ++j)
11096             {
11097               nzero_counts += counts[j] * j;
11098               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11099                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11100                       (nzero_counts * 100.0) / nsyms);
11101             }
11102         }
11103
11104       free (counts);
11105       free (lengths);
11106       free (gnubuckets);
11107       free (gnuchains);
11108     }
11109
11110   return 1;
11111 }
11112
11113 static int
11114 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11115 {
11116   unsigned int i;
11117
11118   if (dynamic_syminfo == NULL
11119       || !do_dynamic)
11120     /* No syminfo, this is ok.  */
11121     return 1;
11122
11123   /* There better should be a dynamic symbol section.  */
11124   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11125     return 0;
11126
11127   if (dynamic_addr)
11128     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11129             dynamic_syminfo_offset, dynamic_syminfo_nent);
11130
11131   printf (_(" Num: Name                           BoundTo     Flags\n"));
11132   for (i = 0; i < dynamic_syminfo_nent; ++i)
11133     {
11134       unsigned short int flags = dynamic_syminfo[i].si_flags;
11135
11136       printf ("%4d: ", i);
11137       if (i >= num_dynamic_syms)
11138         printf (_("<corrupt index>"));
11139       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11140         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11141       else
11142         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11143       putchar (' ');
11144
11145       switch (dynamic_syminfo[i].si_boundto)
11146         {
11147         case SYMINFO_BT_SELF:
11148           fputs ("SELF       ", stdout);
11149           break;
11150         case SYMINFO_BT_PARENT:
11151           fputs ("PARENT     ", stdout);
11152           break;
11153         default:
11154           if (dynamic_syminfo[i].si_boundto > 0
11155               && dynamic_syminfo[i].si_boundto < dynamic_nent
11156               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11157             {
11158               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11159               putchar (' ' );
11160             }
11161           else
11162             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11163           break;
11164         }
11165
11166       if (flags & SYMINFO_FLG_DIRECT)
11167         printf (" DIRECT");
11168       if (flags & SYMINFO_FLG_PASSTHRU)
11169         printf (" PASSTHRU");
11170       if (flags & SYMINFO_FLG_COPY)
11171         printf (" COPY");
11172       if (flags & SYMINFO_FLG_LAZYLOAD)
11173         printf (" LAZYLOAD");
11174
11175       puts ("");
11176     }
11177
11178   return 1;
11179 }
11180
11181 /* Check to see if the given reloc needs to be handled in a target specific
11182    manner.  If so then process the reloc and return TRUE otherwise return
11183    FALSE.  */
11184
11185 static bfd_boolean
11186 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11187                                 unsigned char *     start,
11188                                 Elf_Internal_Sym *  symtab)
11189 {
11190   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11191
11192   switch (elf_header.e_machine)
11193     {
11194     case EM_MSP430:
11195     case EM_MSP430_OLD:
11196       {
11197         static Elf_Internal_Sym * saved_sym = NULL;
11198
11199         switch (reloc_type)
11200           {
11201           case 10: /* R_MSP430_SYM_DIFF */
11202             if (uses_msp430x_relocs ())
11203               break;
11204           case 21: /* R_MSP430X_SYM_DIFF */
11205             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11206             return TRUE;
11207
11208           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11209           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11210             goto handle_sym_diff;
11211
11212           case 5: /* R_MSP430_16_BYTE */
11213           case 9: /* R_MSP430_8 */
11214             if (uses_msp430x_relocs ())
11215               break;
11216             goto handle_sym_diff;
11217
11218           case 2: /* R_MSP430_ABS16 */
11219           case 15: /* R_MSP430X_ABS16 */
11220             if (! uses_msp430x_relocs ())
11221               break;
11222             goto handle_sym_diff;
11223
11224           handle_sym_diff:
11225             if (saved_sym != NULL)
11226               {
11227                 bfd_vma value;
11228
11229                 value = reloc->r_addend
11230                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11231                      - saved_sym->st_value);
11232
11233                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11234
11235                 saved_sym = NULL;
11236                 return TRUE;
11237               }
11238             break;
11239
11240           default:
11241             if (saved_sym != NULL)
11242               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11243             break;
11244           }
11245         break;
11246       }
11247
11248     case EM_MN10300:
11249     case EM_CYGNUS_MN10300:
11250       {
11251         static Elf_Internal_Sym * saved_sym = NULL;
11252
11253         switch (reloc_type)
11254           {
11255           case 34: /* R_MN10300_ALIGN */
11256             return TRUE;
11257           case 33: /* R_MN10300_SYM_DIFF */
11258             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11259             return TRUE;
11260           case 1: /* R_MN10300_32 */
11261           case 2: /* R_MN10300_16 */
11262             if (saved_sym != NULL)
11263               {
11264                 bfd_vma value;
11265
11266                 value = reloc->r_addend
11267                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11268                      - saved_sym->st_value);
11269
11270                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11271
11272                 saved_sym = NULL;
11273                 return TRUE;
11274               }
11275             break;
11276           default:
11277             if (saved_sym != NULL)
11278               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11279             break;
11280           }
11281         break;
11282       }
11283
11284     case EM_RL78:
11285       {
11286         static bfd_vma saved_sym1 = 0;
11287         static bfd_vma saved_sym2 = 0;
11288         static bfd_vma value;
11289
11290         switch (reloc_type)
11291           {
11292           case 0x80: /* R_RL78_SYM.  */
11293             saved_sym1 = saved_sym2;
11294             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11295             saved_sym2 += reloc->r_addend;
11296             return TRUE;
11297
11298           case 0x83: /* R_RL78_OPsub.  */
11299             value = saved_sym1 - saved_sym2;
11300             saved_sym2 = saved_sym1 = 0;
11301             return TRUE;
11302             break;
11303
11304           case 0x41: /* R_RL78_ABS32.  */
11305             byte_put (start + reloc->r_offset, value, 4);
11306             value = 0;
11307             return TRUE;
11308
11309           case 0x43: /* R_RL78_ABS16.  */
11310             byte_put (start + reloc->r_offset, value, 2);
11311             value = 0;
11312             return TRUE;
11313
11314           default:
11315             break;
11316           }
11317         break;
11318       }
11319     }
11320
11321   return FALSE;
11322 }
11323
11324 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11325    DWARF debug sections.  This is a target specific test.  Note - we do not
11326    go through the whole including-target-headers-multiple-times route, (as
11327    we have already done with <elf/h8.h>) because this would become very
11328    messy and even then this function would have to contain target specific
11329    information (the names of the relocs instead of their numeric values).
11330    FIXME: This is not the correct way to solve this problem.  The proper way
11331    is to have target specific reloc sizing and typing functions created by
11332    the reloc-macros.h header, in the same way that it already creates the
11333    reloc naming functions.  */
11334
11335 static bfd_boolean
11336 is_32bit_abs_reloc (unsigned int reloc_type)
11337 {
11338   switch (elf_header.e_machine)
11339     {
11340     case EM_386:
11341     case EM_IAMCU:
11342       return reloc_type == 1; /* R_386_32.  */
11343     case EM_68K:
11344       return reloc_type == 1; /* R_68K_32.  */
11345     case EM_860:
11346       return reloc_type == 1; /* R_860_32.  */
11347     case EM_960:
11348       return reloc_type == 2; /* R_960_32.  */
11349     case EM_AARCH64:
11350       return reloc_type == 258; /* R_AARCH64_ABS32 */
11351     case EM_ALPHA:
11352       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11353     case EM_ARC:
11354       return reloc_type == 1; /* R_ARC_32.  */
11355     case EM_ARC_COMPACT:
11356     case EM_ARC_COMPACT2:
11357       return reloc_type == 4; /* R_ARC_32.  */
11358     case EM_ARM:
11359       return reloc_type == 2; /* R_ARM_ABS32 */
11360     case EM_AVR_OLD:
11361     case EM_AVR:
11362       return reloc_type == 1;
11363     case EM_ADAPTEVA_EPIPHANY:
11364       return reloc_type == 3;
11365     case EM_BLACKFIN:
11366       return reloc_type == 0x12; /* R_byte4_data.  */
11367     case EM_CRIS:
11368       return reloc_type == 3; /* R_CRIS_32.  */
11369     case EM_CR16:
11370       return reloc_type == 3; /* R_CR16_NUM32.  */
11371     case EM_CRX:
11372       return reloc_type == 15; /* R_CRX_NUM32.  */
11373     case EM_CYGNUS_FRV:
11374       return reloc_type == 1;
11375     case EM_CYGNUS_D10V:
11376     case EM_D10V:
11377       return reloc_type == 6; /* R_D10V_32.  */
11378     case EM_CYGNUS_D30V:
11379     case EM_D30V:
11380       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11381     case EM_DLX:
11382       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11383     case EM_CYGNUS_FR30:
11384     case EM_FR30:
11385       return reloc_type == 3; /* R_FR30_32.  */
11386     case EM_FT32:
11387       return reloc_type == 1; /* R_FT32_32.  */
11388     case EM_H8S:
11389     case EM_H8_300:
11390     case EM_H8_300H:
11391       return reloc_type == 1; /* R_H8_DIR32.  */
11392     case EM_IA_64:
11393       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11394         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11395     case EM_IP2K_OLD:
11396     case EM_IP2K:
11397       return reloc_type == 2; /* R_IP2K_32.  */
11398     case EM_IQ2000:
11399       return reloc_type == 2; /* R_IQ2000_32.  */
11400     case EM_LATTICEMICO32:
11401       return reloc_type == 3; /* R_LM32_32.  */
11402     case EM_M32C_OLD:
11403     case EM_M32C:
11404       return reloc_type == 3; /* R_M32C_32.  */
11405     case EM_M32R:
11406       return reloc_type == 34; /* R_M32R_32_RELA.  */
11407     case EM_68HC11:
11408     case EM_68HC12:
11409       return reloc_type == 6; /* R_M68HC11_32.  */
11410     case EM_MCORE:
11411       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11412     case EM_CYGNUS_MEP:
11413       return reloc_type == 4; /* R_MEP_32.  */
11414     case EM_METAG:
11415       return reloc_type == 2; /* R_METAG_ADDR32.  */
11416     case EM_MICROBLAZE:
11417       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11418     case EM_MIPS:
11419       return reloc_type == 2; /* R_MIPS_32.  */
11420     case EM_MMIX:
11421       return reloc_type == 4; /* R_MMIX_32.  */
11422     case EM_CYGNUS_MN10200:
11423     case EM_MN10200:
11424       return reloc_type == 1; /* R_MN10200_32.  */
11425     case EM_CYGNUS_MN10300:
11426     case EM_MN10300:
11427       return reloc_type == 1; /* R_MN10300_32.  */
11428     case EM_MOXIE:
11429       return reloc_type == 1; /* R_MOXIE_32.  */
11430     case EM_MSP430_OLD:
11431     case EM_MSP430:
11432       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11433     case EM_MT:
11434       return reloc_type == 2; /* R_MT_32.  */
11435     case EM_NDS32:
11436       return reloc_type == 20; /* R_NDS32_RELA.  */
11437     case EM_ALTERA_NIOS2:
11438       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11439     case EM_NIOS32:
11440       return reloc_type == 1; /* R_NIOS_32.  */
11441     case EM_OR1K:
11442       return reloc_type == 1; /* R_OR1K_32.  */
11443     case EM_PARISC:
11444       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11445               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11446     case EM_PJ:
11447     case EM_PJ_OLD:
11448       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11449     case EM_PPC64:
11450       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11451     case EM_PPC:
11452       return reloc_type == 1; /* R_PPC_ADDR32.  */
11453     case EM_RL78:
11454       return reloc_type == 1; /* R_RL78_DIR32.  */
11455     case EM_RX:
11456       return reloc_type == 1; /* R_RX_DIR32.  */
11457     case EM_S370:
11458       return reloc_type == 1; /* R_I370_ADDR31.  */
11459     case EM_S390_OLD:
11460     case EM_S390:
11461       return reloc_type == 4; /* R_S390_32.  */
11462     case EM_SCORE:
11463       return reloc_type == 8; /* R_SCORE_ABS32.  */
11464     case EM_SH:
11465       return reloc_type == 1; /* R_SH_DIR32.  */
11466     case EM_SPARC32PLUS:
11467     case EM_SPARCV9:
11468     case EM_SPARC:
11469       return reloc_type == 3 /* R_SPARC_32.  */
11470         || reloc_type == 23; /* R_SPARC_UA32.  */
11471     case EM_SPU:
11472       return reloc_type == 6; /* R_SPU_ADDR32 */
11473     case EM_TI_C6000:
11474       return reloc_type == 1; /* R_C6000_ABS32.  */
11475     case EM_TILEGX:
11476       return reloc_type == 2; /* R_TILEGX_32.  */
11477     case EM_TILEPRO:
11478       return reloc_type == 1; /* R_TILEPRO_32.  */
11479     case EM_CYGNUS_V850:
11480     case EM_V850:
11481       return reloc_type == 6; /* R_V850_ABS32.  */
11482     case EM_V800:
11483       return reloc_type == 0x33; /* R_V810_WORD.  */
11484     case EM_VAX:
11485       return reloc_type == 1; /* R_VAX_32.  */
11486     case EM_VISIUM:
11487       return reloc_type == 3;  /* R_VISIUM_32. */
11488     case EM_X86_64:
11489     case EM_L1OM:
11490     case EM_K1OM:
11491       return reloc_type == 10; /* R_X86_64_32.  */
11492     case EM_XC16X:
11493     case EM_C166:
11494       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11495     case EM_XGATE:
11496       return reloc_type == 4; /* R_XGATE_32.  */
11497     case EM_XSTORMY16:
11498       return reloc_type == 1; /* R_XSTROMY16_32.  */
11499     case EM_XTENSA_OLD:
11500     case EM_XTENSA:
11501       return reloc_type == 1; /* R_XTENSA_32.  */
11502     default:
11503       {
11504         static unsigned int prev_warn = 0;
11505
11506         /* Avoid repeating the same warning multiple times.  */
11507         if (prev_warn != elf_header.e_machine)
11508           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11509                  elf_header.e_machine);
11510         prev_warn = elf_header.e_machine;
11511         return FALSE;
11512       }
11513     }
11514 }
11515
11516 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11517    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11518
11519 static bfd_boolean
11520 is_32bit_pcrel_reloc (unsigned int reloc_type)
11521 {
11522   switch (elf_header.e_machine)
11523     {
11524     case EM_386:
11525     case EM_IAMCU:
11526       return reloc_type == 2;  /* R_386_PC32.  */
11527     case EM_68K:
11528       return reloc_type == 4;  /* R_68K_PC32.  */
11529     case EM_AARCH64:
11530       return reloc_type == 261; /* R_AARCH64_PREL32 */
11531     case EM_ADAPTEVA_EPIPHANY:
11532       return reloc_type == 6;
11533     case EM_ALPHA:
11534       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11535     case EM_ARM:
11536       return reloc_type == 3;  /* R_ARM_REL32 */
11537     case EM_MICROBLAZE:
11538       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11539     case EM_OR1K:
11540       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11541     case EM_PARISC:
11542       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11543     case EM_PPC:
11544       return reloc_type == 26; /* R_PPC_REL32.  */
11545     case EM_PPC64:
11546       return reloc_type == 26; /* R_PPC64_REL32.  */
11547     case EM_S390_OLD:
11548     case EM_S390:
11549       return reloc_type == 5;  /* R_390_PC32.  */
11550     case EM_SH:
11551       return reloc_type == 2;  /* R_SH_REL32.  */
11552     case EM_SPARC32PLUS:
11553     case EM_SPARCV9:
11554     case EM_SPARC:
11555       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11556     case EM_SPU:
11557       return reloc_type == 13; /* R_SPU_REL32.  */
11558     case EM_TILEGX:
11559       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11560     case EM_TILEPRO:
11561       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11562     case EM_VISIUM:
11563       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11564     case EM_X86_64:
11565     case EM_L1OM:
11566     case EM_K1OM:
11567       return reloc_type == 2;  /* R_X86_64_PC32.  */
11568     case EM_XTENSA_OLD:
11569     case EM_XTENSA:
11570       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11571     default:
11572       /* Do not abort or issue an error message here.  Not all targets use
11573          pc-relative 32-bit relocs in their DWARF debug information and we
11574          have already tested for target coverage in is_32bit_abs_reloc.  A
11575          more helpful warning message will be generated by apply_relocations
11576          anyway, so just return.  */
11577       return FALSE;
11578     }
11579 }
11580
11581 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11582    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11583
11584 static bfd_boolean
11585 is_64bit_abs_reloc (unsigned int reloc_type)
11586 {
11587   switch (elf_header.e_machine)
11588     {
11589     case EM_AARCH64:
11590       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11591     case EM_ALPHA:
11592       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11593     case EM_IA_64:
11594       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11595     case EM_PARISC:
11596       return reloc_type == 80; /* R_PARISC_DIR64.  */
11597     case EM_PPC64:
11598       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11599     case EM_SPARC32PLUS:
11600     case EM_SPARCV9:
11601     case EM_SPARC:
11602       return reloc_type == 54; /* R_SPARC_UA64.  */
11603     case EM_X86_64:
11604     case EM_L1OM:
11605     case EM_K1OM:
11606       return reloc_type == 1; /* R_X86_64_64.  */
11607     case EM_S390_OLD:
11608     case EM_S390:
11609       return reloc_type == 22;  /* R_S390_64.  */
11610     case EM_TILEGX:
11611       return reloc_type == 1; /* R_TILEGX_64.  */
11612     case EM_MIPS:
11613       return reloc_type == 18;  /* R_MIPS_64.  */
11614     default:
11615       return FALSE;
11616     }
11617 }
11618
11619 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11620    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11621
11622 static bfd_boolean
11623 is_64bit_pcrel_reloc (unsigned int reloc_type)
11624 {
11625   switch (elf_header.e_machine)
11626     {
11627     case EM_AARCH64:
11628       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11629     case EM_ALPHA:
11630       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11631     case EM_IA_64:
11632       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11633     case EM_PARISC:
11634       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11635     case EM_PPC64:
11636       return reloc_type == 44; /* R_PPC64_REL64.  */
11637     case EM_SPARC32PLUS:
11638     case EM_SPARCV9:
11639     case EM_SPARC:
11640       return reloc_type == 46; /* R_SPARC_DISP64.  */
11641     case EM_X86_64:
11642     case EM_L1OM:
11643     case EM_K1OM:
11644       return reloc_type == 24; /* R_X86_64_PC64.  */
11645     case EM_S390_OLD:
11646     case EM_S390:
11647       return reloc_type == 23;  /* R_S390_PC64.  */
11648     case EM_TILEGX:
11649       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11650     default:
11651       return FALSE;
11652     }
11653 }
11654
11655 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11656    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11657
11658 static bfd_boolean
11659 is_24bit_abs_reloc (unsigned int reloc_type)
11660 {
11661   switch (elf_header.e_machine)
11662     {
11663     case EM_CYGNUS_MN10200:
11664     case EM_MN10200:
11665       return reloc_type == 4; /* R_MN10200_24.  */
11666     default:
11667       return FALSE;
11668     }
11669 }
11670
11671 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11672    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11673
11674 static bfd_boolean
11675 is_16bit_abs_reloc (unsigned int reloc_type)
11676 {
11677   switch (elf_header.e_machine)
11678     {
11679     case EM_ARC:
11680     case EM_ARC_COMPACT:
11681     case EM_ARC_COMPACT2:
11682       return reloc_type == 2; /* R_ARC_16.  */
11683     case EM_AVR_OLD:
11684     case EM_AVR:
11685       return reloc_type == 4; /* R_AVR_16.  */
11686     case EM_ADAPTEVA_EPIPHANY:
11687       return reloc_type == 5;
11688     case EM_CYGNUS_D10V:
11689     case EM_D10V:
11690       return reloc_type == 3; /* R_D10V_16.  */
11691     case EM_H8S:
11692     case EM_H8_300:
11693     case EM_H8_300H:
11694       return reloc_type == R_H8_DIR16;
11695     case EM_IP2K_OLD:
11696     case EM_IP2K:
11697       return reloc_type == 1; /* R_IP2K_16.  */
11698     case EM_M32C_OLD:
11699     case EM_M32C:
11700       return reloc_type == 1; /* R_M32C_16 */
11701     case EM_MSP430:
11702       if (uses_msp430x_relocs ())
11703         return reloc_type == 2; /* R_MSP430_ABS16.  */
11704     case EM_MSP430_OLD:
11705       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11706     case EM_NDS32:
11707       return reloc_type == 19; /* R_NDS32_RELA.  */
11708     case EM_ALTERA_NIOS2:
11709       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11710     case EM_NIOS32:
11711       return reloc_type == 9; /* R_NIOS_16.  */
11712     case EM_OR1K:
11713       return reloc_type == 2; /* R_OR1K_16.  */
11714     case EM_TI_C6000:
11715       return reloc_type == 2; /* R_C6000_ABS16.  */
11716     case EM_XC16X:
11717     case EM_C166:
11718       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11719     case EM_CYGNUS_MN10200:
11720     case EM_MN10200:
11721       return reloc_type == 2; /* R_MN10200_16.  */
11722     case EM_CYGNUS_MN10300:
11723     case EM_MN10300:
11724       return reloc_type == 2; /* R_MN10300_16.  */
11725     case EM_VISIUM:
11726       return reloc_type == 2; /* R_VISIUM_16. */
11727     case EM_XGATE:
11728       return reloc_type == 3; /* R_XGATE_16.  */
11729     default:
11730       return FALSE;
11731     }
11732 }
11733
11734 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11735    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11736
11737 static bfd_boolean
11738 is_none_reloc (unsigned int reloc_type)
11739 {
11740   switch (elf_header.e_machine)
11741     {
11742     case EM_68K:     /* R_68K_NONE.  */
11743     case EM_386:     /* R_386_NONE.  */
11744     case EM_SPARC32PLUS:
11745     case EM_SPARCV9:
11746     case EM_SPARC:   /* R_SPARC_NONE.  */
11747     case EM_MIPS:    /* R_MIPS_NONE.  */
11748     case EM_PARISC:  /* R_PARISC_NONE.  */
11749     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11750     case EM_ADAPTEVA_EPIPHANY:
11751     case EM_PPC:     /* R_PPC_NONE.  */
11752     case EM_PPC64:   /* R_PPC64_NONE.  */
11753     case EM_ARC:     /* R_ARC_NONE.  */
11754     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
11755     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
11756     case EM_ARM:     /* R_ARM_NONE.  */
11757     case EM_IA_64:   /* R_IA64_NONE.  */
11758     case EM_SH:      /* R_SH_NONE.  */
11759     case EM_S390_OLD:
11760     case EM_S390:    /* R_390_NONE.  */
11761     case EM_CRIS:    /* R_CRIS_NONE.  */
11762     case EM_X86_64:  /* R_X86_64_NONE.  */
11763     case EM_L1OM:    /* R_X86_64_NONE.  */
11764     case EM_K1OM:    /* R_X86_64_NONE.  */
11765     case EM_MN10300: /* R_MN10300_NONE.  */
11766     case EM_FT32:    /* R_FT32_NONE.  */
11767     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11768     case EM_M32R:    /* R_M32R_NONE.  */
11769     case EM_TI_C6000:/* R_C6000_NONE.  */
11770     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11771     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11772     case EM_XC16X:
11773     case EM_C166:    /* R_XC16X_NONE.  */
11774     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11775     case EM_NIOS32:  /* R_NIOS_NONE.  */
11776     case EM_OR1K:    /* R_OR1K_NONE. */
11777       return reloc_type == 0;
11778     case EM_AARCH64:
11779       return reloc_type == 0 || reloc_type == 256;
11780     case EM_NDS32:
11781       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11782               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11783               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11784               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11785               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11786     case EM_XTENSA_OLD:
11787     case EM_XTENSA:
11788       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11789               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11790               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11791               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11792     case EM_METAG:
11793       return reloc_type == 3; /* R_METAG_NONE.  */
11794     }
11795   return FALSE;
11796 }
11797
11798 /* Returns TRUE if there is a relocation against
11799    section NAME at OFFSET bytes.  */
11800
11801 bfd_boolean
11802 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11803 {
11804   Elf_Internal_Rela * relocs;
11805   Elf_Internal_Rela * rp;
11806
11807   if (dsec == NULL || dsec->reloc_info == NULL)
11808     return FALSE;
11809
11810   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11811
11812   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11813     if (rp->r_offset == offset)
11814       return TRUE;
11815
11816    return FALSE;
11817 }
11818
11819 /* Apply relocations to a section.
11820    Note: So far support has been added only for those relocations
11821    which can be found in debug sections.
11822    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11823    loaded relocs.  It is then the caller's responsibility to free them.
11824    FIXME: Add support for more relocations ?  */
11825
11826 static void
11827 apply_relocations (void *                     file,
11828                    const Elf_Internal_Shdr *  section,
11829                    unsigned char *            start,
11830                    bfd_size_type              size,
11831                    void **                     relocs_return,
11832                    unsigned long *            num_relocs_return)
11833 {
11834   Elf_Internal_Shdr * relsec;
11835   unsigned char * end = start + size;
11836
11837   if (relocs_return != NULL)
11838     {
11839       * (Elf_Internal_Rela **) relocs_return = NULL;
11840       * num_relocs_return = 0;
11841     }
11842
11843   if (elf_header.e_type != ET_REL)
11844     return;
11845
11846   /* Find the reloc section associated with the section.  */
11847   for (relsec = section_headers;
11848        relsec < section_headers + elf_header.e_shnum;
11849        ++relsec)
11850     {
11851       bfd_boolean is_rela;
11852       unsigned long num_relocs;
11853       Elf_Internal_Rela * relocs;
11854       Elf_Internal_Rela * rp;
11855       Elf_Internal_Shdr * symsec;
11856       Elf_Internal_Sym * symtab;
11857       unsigned long num_syms;
11858       Elf_Internal_Sym * sym;
11859
11860       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11861           || relsec->sh_info >= elf_header.e_shnum
11862           || section_headers + relsec->sh_info != section
11863           || relsec->sh_size == 0
11864           || relsec->sh_link >= elf_header.e_shnum)
11865         continue;
11866
11867       is_rela = relsec->sh_type == SHT_RELA;
11868
11869       if (is_rela)
11870         {
11871           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11872                                   relsec->sh_size, & relocs, & num_relocs))
11873             return;
11874         }
11875       else
11876         {
11877           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11878                                  relsec->sh_size, & relocs, & num_relocs))
11879             return;
11880         }
11881
11882       /* SH uses RELA but uses in place value instead of the addend field.  */
11883       if (elf_header.e_machine == EM_SH)
11884         is_rela = FALSE;
11885
11886       symsec = section_headers + relsec->sh_link;
11887       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11888
11889       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11890         {
11891           bfd_vma         addend;
11892           unsigned int    reloc_type;
11893           unsigned int    reloc_size;
11894           unsigned char * rloc;
11895           unsigned long   sym_index;
11896
11897           reloc_type = get_reloc_type (rp->r_info);
11898
11899           if (target_specific_reloc_handling (rp, start, symtab))
11900             continue;
11901           else if (is_none_reloc (reloc_type))
11902             continue;
11903           else if (is_32bit_abs_reloc (reloc_type)
11904                    || is_32bit_pcrel_reloc (reloc_type))
11905             reloc_size = 4;
11906           else if (is_64bit_abs_reloc (reloc_type)
11907                    || is_64bit_pcrel_reloc (reloc_type))
11908             reloc_size = 8;
11909           else if (is_24bit_abs_reloc (reloc_type))
11910             reloc_size = 3;
11911           else if (is_16bit_abs_reloc (reloc_type))
11912             reloc_size = 2;
11913           else
11914             {
11915               static unsigned int prev_reloc = 0;
11916               if (reloc_type != prev_reloc)
11917                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11918                       reloc_type, printable_section_name (section));
11919               prev_reloc = reloc_type;
11920               continue;
11921             }
11922
11923           rloc = start + rp->r_offset;
11924           if ((rloc + reloc_size) > end || (rloc < start))
11925             {
11926               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11927                     (unsigned long) rp->r_offset,
11928                     printable_section_name (section));
11929               continue;
11930             }
11931
11932           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11933           if (sym_index >= num_syms)
11934             {
11935               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11936                     sym_index, printable_section_name (section));
11937               continue;
11938             }
11939           sym = symtab + sym_index;
11940
11941           /* If the reloc has a symbol associated with it,
11942              make sure that it is of an appropriate type.
11943
11944              Relocations against symbols without type can happen.
11945              Gcc -feliminate-dwarf2-dups may generate symbols
11946              without type for debug info.
11947
11948              Icc generates relocations against function symbols
11949              instead of local labels.
11950
11951              Relocations against object symbols can happen, eg when
11952              referencing a global array.  For an example of this see
11953              the _clz.o binary in libgcc.a.  */
11954           if (sym != symtab
11955               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11956             {
11957               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11958                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11959                     (long int)(rp - relocs),
11960                     printable_section_name (relsec));
11961               continue;
11962             }
11963
11964           addend = 0;
11965           if (is_rela)
11966             addend += rp->r_addend;
11967           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11968              partial_inplace.  */
11969           if (!is_rela
11970               || (elf_header.e_machine == EM_XTENSA
11971                   && reloc_type == 1)
11972               || ((elf_header.e_machine == EM_PJ
11973                    || elf_header.e_machine == EM_PJ_OLD)
11974                   && reloc_type == 1)
11975               || ((elf_header.e_machine == EM_D30V
11976                    || elf_header.e_machine == EM_CYGNUS_D30V)
11977                   && reloc_type == 12))
11978             addend += byte_get (rloc, reloc_size);
11979
11980           if (is_32bit_pcrel_reloc (reloc_type)
11981               || is_64bit_pcrel_reloc (reloc_type))
11982             {
11983               /* On HPPA, all pc-relative relocations are biased by 8.  */
11984               if (elf_header.e_machine == EM_PARISC)
11985                 addend -= 8;
11986               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11987                         reloc_size);
11988             }
11989           else
11990             byte_put (rloc, addend + sym->st_value, reloc_size);
11991         }
11992
11993       free (symtab);
11994
11995       if (relocs_return)
11996         {
11997           * (Elf_Internal_Rela **) relocs_return = relocs;
11998           * num_relocs_return = num_relocs;
11999         }
12000       else
12001         free (relocs);
12002
12003       break;
12004     }
12005 }
12006
12007 #ifdef SUPPORT_DISASSEMBLY
12008 static int
12009 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12010 {
12011   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12012
12013   /* FIXME: XXX -- to be done --- XXX */
12014
12015   return 1;
12016 }
12017 #endif
12018
12019 /* Reads in the contents of SECTION from FILE, returning a pointer
12020    to a malloc'ed buffer or NULL if something went wrong.  */
12021
12022 static char *
12023 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12024 {
12025   bfd_size_type num_bytes;
12026
12027   num_bytes = section->sh_size;
12028
12029   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12030     {
12031       printf (_("\nSection '%s' has no data to dump.\n"),
12032               printable_section_name (section));
12033       return NULL;
12034     }
12035
12036   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12037                              _("section contents"));
12038 }
12039
12040 /* Uncompresses a section that was compressed using zlib, in place.  */
12041
12042 static bfd_boolean
12043 uncompress_section_contents (unsigned char **buffer,
12044                              dwarf_size_type uncompressed_size,
12045                              dwarf_size_type *size)
12046 {
12047   dwarf_size_type compressed_size = *size;
12048   unsigned char * compressed_buffer = *buffer;
12049   unsigned char * uncompressed_buffer;
12050   z_stream strm;
12051   int rc;
12052
12053   /* It is possible the section consists of several compressed
12054      buffers concatenated together, so we uncompress in a loop.  */
12055   /* PR 18313: The state field in the z_stream structure is supposed
12056      to be invisible to the user (ie us), but some compilers will
12057      still complain about it being used without initialisation.  So
12058      we first zero the entire z_stream structure and then set the fields
12059      that we need.  */
12060   memset (& strm, 0, sizeof strm);
12061   strm.avail_in = compressed_size;
12062   strm.next_in = (Bytef *) compressed_buffer;
12063   strm.avail_out = uncompressed_size;
12064   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12065
12066   rc = inflateInit (& strm);
12067   while (strm.avail_in > 0)
12068     {
12069       if (rc != Z_OK)
12070         goto fail;
12071       strm.next_out = ((Bytef *) uncompressed_buffer
12072                        + (uncompressed_size - strm.avail_out));
12073       rc = inflate (&strm, Z_FINISH);
12074       if (rc != Z_STREAM_END)
12075         goto fail;
12076       rc = inflateReset (& strm);
12077     }
12078   rc = inflateEnd (& strm);
12079   if (rc != Z_OK
12080       || strm.avail_out != 0)
12081     goto fail;
12082
12083   *buffer = uncompressed_buffer;
12084   *size = uncompressed_size;
12085   return TRUE;
12086
12087  fail:
12088   free (uncompressed_buffer);
12089   /* Indicate decompression failure.  */
12090   *buffer = NULL;
12091   return FALSE;
12092 }
12093
12094 static void
12095 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12096 {
12097   Elf_Internal_Shdr *  relsec;
12098   bfd_size_type        num_bytes;
12099   unsigned char *      data;
12100   unsigned char *      end;
12101   unsigned char *      real_start;
12102   unsigned char *      start;
12103   bfd_boolean          some_strings_shown;
12104
12105   real_start = start = (unsigned char *) get_section_contents (section,
12106                                                                file);
12107   if (start == NULL)
12108     return;
12109   num_bytes = section->sh_size;
12110
12111   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12112
12113   if (decompress_dumps)
12114     {
12115       dwarf_size_type new_size = num_bytes;
12116       dwarf_size_type uncompressed_size = 0;
12117
12118       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12119         {
12120           Elf_Internal_Chdr chdr;
12121           unsigned int compression_header_size
12122             = get_compression_header (& chdr, (unsigned char *) start);
12123
12124           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12125             {
12126               warn (_("section '%s' has unsupported compress type: %d\n"),
12127                     printable_section_name (section), chdr.ch_type);
12128               return;
12129             }
12130           else if (chdr.ch_addralign != section->sh_addralign)
12131             {
12132               warn (_("compressed section '%s' is corrupted\n"),
12133                     printable_section_name (section));
12134               return;
12135             }
12136           uncompressed_size = chdr.ch_size;
12137           start += compression_header_size;
12138           new_size -= compression_header_size;
12139         }
12140       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12141         {
12142           /* Read the zlib header.  In this case, it should be "ZLIB"
12143              followed by the uncompressed section size, 8 bytes in
12144              big-endian order.  */
12145           uncompressed_size = start[4]; uncompressed_size <<= 8;
12146           uncompressed_size += start[5]; uncompressed_size <<= 8;
12147           uncompressed_size += start[6]; uncompressed_size <<= 8;
12148           uncompressed_size += start[7]; uncompressed_size <<= 8;
12149           uncompressed_size += start[8]; uncompressed_size <<= 8;
12150           uncompressed_size += start[9]; uncompressed_size <<= 8;
12151           uncompressed_size += start[10]; uncompressed_size <<= 8;
12152           uncompressed_size += start[11];
12153           start += 12;
12154           new_size -= 12;
12155         }
12156
12157       if (uncompressed_size
12158           && uncompress_section_contents (& start,
12159                                           uncompressed_size, & new_size))
12160         num_bytes = new_size;
12161     }
12162
12163   /* If the section being dumped has relocations against it the user might
12164      be expecting these relocations to have been applied.  Check for this
12165      case and issue a warning message in order to avoid confusion.
12166      FIXME: Maybe we ought to have an option that dumps a section with
12167      relocs applied ?  */
12168   for (relsec = section_headers;
12169        relsec < section_headers + elf_header.e_shnum;
12170        ++relsec)
12171     {
12172       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12173           || relsec->sh_info >= elf_header.e_shnum
12174           || section_headers + relsec->sh_info != section
12175           || relsec->sh_size == 0
12176           || relsec->sh_link >= elf_header.e_shnum)
12177         continue;
12178
12179       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12180       break;
12181     }
12182
12183   data = start;
12184   end  = start + num_bytes;
12185   some_strings_shown = FALSE;
12186
12187   while (data < end)
12188     {
12189       while (!ISPRINT (* data))
12190         if (++ data >= end)
12191           break;
12192
12193       if (data < end)
12194         {
12195           size_t maxlen = end - data;
12196
12197 #ifndef __MSVCRT__
12198           /* PR 11128: Use two separate invocations in order to work
12199              around bugs in the Solaris 8 implementation of printf.  */
12200           printf ("  [%6tx]  ", data - start);
12201 #else
12202           printf ("  [%6Ix]  ", (size_t) (data - start));
12203 #endif
12204           if (maxlen > 0)
12205             {
12206               print_symbol ((int) maxlen, (const char *) data);
12207               putchar ('\n');
12208               data += strnlen ((const char *) data, maxlen);
12209             }
12210           else
12211             {
12212               printf (_("<corrupt>\n"));
12213               data = end;
12214             }
12215           some_strings_shown = TRUE;
12216         }
12217     }
12218
12219   if (! some_strings_shown)
12220     printf (_("  No strings found in this section."));
12221
12222   free (real_start);
12223
12224   putchar ('\n');
12225 }
12226
12227 static void
12228 dump_section_as_bytes (Elf_Internal_Shdr * section,
12229                        FILE * file,
12230                        bfd_boolean relocate)
12231 {
12232   Elf_Internal_Shdr * relsec;
12233   bfd_size_type       bytes;
12234   bfd_size_type       section_size;
12235   bfd_vma             addr;
12236   unsigned char *     data;
12237   unsigned char *     real_start;
12238   unsigned char *     start;
12239
12240   real_start = start = (unsigned char *) get_section_contents (section, file);
12241   if (start == NULL)
12242     return;
12243   section_size = section->sh_size;
12244
12245   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12246
12247   if (decompress_dumps)
12248     {
12249       dwarf_size_type new_size = section_size;
12250       dwarf_size_type uncompressed_size = 0;
12251
12252       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12253         {
12254           Elf_Internal_Chdr chdr;
12255           unsigned int compression_header_size
12256             = get_compression_header (& chdr, start);
12257
12258           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12259             {
12260               warn (_("section '%s' has unsupported compress type: %d\n"),
12261                     printable_section_name (section), chdr.ch_type);
12262               return;
12263             }
12264           else if (chdr.ch_addralign != section->sh_addralign)
12265             {
12266               warn (_("compressed section '%s' is corrupted\n"),
12267                     printable_section_name (section));
12268               return;
12269             }
12270           uncompressed_size = chdr.ch_size;
12271           start += compression_header_size;
12272           new_size -= compression_header_size;
12273         }
12274       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12275         {
12276           /* Read the zlib header.  In this case, it should be "ZLIB"
12277              followed by the uncompressed section size, 8 bytes in
12278              big-endian order.  */
12279           uncompressed_size = start[4]; uncompressed_size <<= 8;
12280           uncompressed_size += start[5]; uncompressed_size <<= 8;
12281           uncompressed_size += start[6]; uncompressed_size <<= 8;
12282           uncompressed_size += start[7]; uncompressed_size <<= 8;
12283           uncompressed_size += start[8]; uncompressed_size <<= 8;
12284           uncompressed_size += start[9]; uncompressed_size <<= 8;
12285           uncompressed_size += start[10]; uncompressed_size <<= 8;
12286           uncompressed_size += start[11];
12287           start += 12;
12288           new_size -= 12;
12289         }
12290
12291       if (uncompressed_size
12292           && uncompress_section_contents (& start, uncompressed_size,
12293                                           & new_size))
12294         section_size = new_size;
12295     }
12296
12297   if (relocate)
12298     {
12299       apply_relocations (file, section, start, section_size, NULL, NULL);
12300     }
12301   else
12302     {
12303       /* If the section being dumped has relocations against it the user might
12304          be expecting these relocations to have been applied.  Check for this
12305          case and issue a warning message in order to avoid confusion.
12306          FIXME: Maybe we ought to have an option that dumps a section with
12307          relocs applied ?  */
12308       for (relsec = section_headers;
12309            relsec < section_headers + elf_header.e_shnum;
12310            ++relsec)
12311         {
12312           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12313               || relsec->sh_info >= elf_header.e_shnum
12314               || section_headers + relsec->sh_info != section
12315               || relsec->sh_size == 0
12316               || relsec->sh_link >= elf_header.e_shnum)
12317             continue;
12318
12319           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12320           break;
12321         }
12322     }
12323
12324   addr = section->sh_addr;
12325   bytes = section_size;
12326   data = start;
12327
12328   while (bytes)
12329     {
12330       int j;
12331       int k;
12332       int lbytes;
12333
12334       lbytes = (bytes > 16 ? 16 : bytes);
12335
12336       printf ("  0x%8.8lx ", (unsigned long) addr);
12337
12338       for (j = 0; j < 16; j++)
12339         {
12340           if (j < lbytes)
12341             printf ("%2.2x", data[j]);
12342           else
12343             printf ("  ");
12344
12345           if ((j & 3) == 3)
12346             printf (" ");
12347         }
12348
12349       for (j = 0; j < lbytes; j++)
12350         {
12351           k = data[j];
12352           if (k >= ' ' && k < 0x7f)
12353             printf ("%c", k);
12354           else
12355             printf (".");
12356         }
12357
12358       putchar ('\n');
12359
12360       data  += lbytes;
12361       addr  += lbytes;
12362       bytes -= lbytes;
12363     }
12364
12365   free (real_start);
12366
12367   putchar ('\n');
12368 }
12369
12370 static int
12371 load_specific_debug_section (enum dwarf_section_display_enum debug,
12372                              const Elf_Internal_Shdr * sec, void * file)
12373 {
12374   struct dwarf_section * section = &debug_displays [debug].section;
12375   char buf [64];
12376
12377   /* If it is already loaded, do nothing.  */
12378   if (section->start != NULL)
12379     return 1;
12380
12381   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12382   section->address = sec->sh_addr;
12383   section->user_data = NULL;
12384   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12385                                                sec->sh_offset, 1,
12386                                                sec->sh_size, buf);
12387   if (section->start == NULL)
12388     section->size = 0;
12389   else
12390     {
12391       unsigned char *start = section->start;
12392       dwarf_size_type size = sec->sh_size;
12393       dwarf_size_type uncompressed_size = 0;
12394
12395       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12396         {
12397           Elf_Internal_Chdr chdr;
12398           unsigned int compression_header_size
12399             = get_compression_header (&chdr, start);
12400           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12401             {
12402               warn (_("section '%s' has unsupported compress type: %d\n"),
12403                     section->name, chdr.ch_type);
12404               return 0;
12405             }
12406           else if (chdr.ch_addralign != sec->sh_addralign)
12407             {
12408               warn (_("compressed section '%s' is corrupted\n"),
12409                     section->name);
12410               return 0;
12411             }
12412           uncompressed_size = chdr.ch_size;
12413           start += compression_header_size;
12414           size -= compression_header_size;
12415         }
12416       else if (size > 12 && streq ((char *) start, "ZLIB"))
12417         {
12418           /* Read the zlib header.  In this case, it should be "ZLIB"
12419              followed by the uncompressed section size, 8 bytes in
12420              big-endian order.  */
12421           uncompressed_size = start[4]; uncompressed_size <<= 8;
12422           uncompressed_size += start[5]; uncompressed_size <<= 8;
12423           uncompressed_size += start[6]; uncompressed_size <<= 8;
12424           uncompressed_size += start[7]; uncompressed_size <<= 8;
12425           uncompressed_size += start[8]; uncompressed_size <<= 8;
12426           uncompressed_size += start[9]; uncompressed_size <<= 8;
12427           uncompressed_size += start[10]; uncompressed_size <<= 8;
12428           uncompressed_size += start[11];
12429           start += 12;
12430           size -= 12;
12431         }
12432
12433       if (uncompressed_size
12434           && uncompress_section_contents (&start, uncompressed_size,
12435                                           &size))
12436         {
12437           /* Free the compressed buffer, update the section buffer
12438              and the section size if uncompress is successful.  */
12439           free (section->start);
12440           section->start = start;
12441         }
12442       section->size = size;
12443     }
12444
12445   if (section->start == NULL)
12446     return 0;
12447
12448   if (debug_displays [debug].relocate)
12449     apply_relocations ((FILE *) file, sec, section->start, section->size,
12450                        & section->reloc_info, & section->num_relocs);
12451   else
12452     {
12453       section->reloc_info = NULL;
12454       section->num_relocs = 0;
12455     }
12456
12457   return 1;
12458 }
12459
12460 /* If this is not NULL, load_debug_section will only look for sections
12461    within the list of sections given here.  */
12462 unsigned int *section_subset = NULL;
12463
12464 int
12465 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12466 {
12467   struct dwarf_section * section = &debug_displays [debug].section;
12468   Elf_Internal_Shdr * sec;
12469
12470   /* Locate the debug section.  */
12471   sec = find_section_in_set (section->uncompressed_name, section_subset);
12472   if (sec != NULL)
12473     section->name = section->uncompressed_name;
12474   else
12475     {
12476       sec = find_section_in_set (section->compressed_name, section_subset);
12477       if (sec != NULL)
12478         section->name = section->compressed_name;
12479     }
12480   if (sec == NULL)
12481     return 0;
12482
12483   /* If we're loading from a subset of sections, and we've loaded
12484      a section matching this name before, it's likely that it's a
12485      different one.  */
12486   if (section_subset != NULL)
12487     free_debug_section (debug);
12488
12489   return load_specific_debug_section (debug, sec, (FILE *) file);
12490 }
12491
12492 void
12493 free_debug_section (enum dwarf_section_display_enum debug)
12494 {
12495   struct dwarf_section * section = &debug_displays [debug].section;
12496
12497   if (section->start == NULL)
12498     return;
12499
12500   free ((char *) section->start);
12501   section->start = NULL;
12502   section->address = 0;
12503   section->size = 0;
12504 }
12505
12506 static int
12507 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12508 {
12509   char * name = SECTION_NAME (section);
12510   const char * print_name = printable_section_name (section);
12511   bfd_size_type length;
12512   int result = 1;
12513   int i;
12514
12515   length = section->sh_size;
12516   if (length == 0)
12517     {
12518       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12519       return 0;
12520     }
12521   if (section->sh_type == SHT_NOBITS)
12522     {
12523       /* There is no point in dumping the contents of a debugging section
12524          which has the NOBITS type - the bits in the file will be random.
12525          This can happen when a file containing a .eh_frame section is
12526          stripped with the --only-keep-debug command line option.  */
12527       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12528               print_name);
12529       return 0;
12530     }
12531
12532   if (const_strneq (name, ".gnu.linkonce.wi."))
12533     name = ".debug_info";
12534
12535   /* See if we know how to display the contents of this section.  */
12536   for (i = 0; i < max; i++)
12537     if (streq (debug_displays[i].section.uncompressed_name, name)
12538         || (i == line && const_strneq (name, ".debug_line."))
12539         || streq (debug_displays[i].section.compressed_name, name))
12540       {
12541         struct dwarf_section * sec = &debug_displays [i].section;
12542         int secondary = (section != find_section (name));
12543
12544         if (secondary)
12545           free_debug_section ((enum dwarf_section_display_enum) i);
12546
12547         if (i == line && const_strneq (name, ".debug_line."))
12548           sec->name = name;
12549         else if (streq (sec->uncompressed_name, name))
12550           sec->name = sec->uncompressed_name;
12551         else
12552           sec->name = sec->compressed_name;
12553         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12554                                          section, file))
12555           {
12556             /* If this debug section is part of a CU/TU set in a .dwp file,
12557                restrict load_debug_section to the sections in that set.  */
12558             section_subset = find_cu_tu_set (file, shndx);
12559
12560             result &= debug_displays[i].display (sec, file);
12561
12562             section_subset = NULL;
12563
12564             if (secondary || (i != info && i != abbrev))
12565               free_debug_section ((enum dwarf_section_display_enum) i);
12566           }
12567
12568         break;
12569       }
12570
12571   if (i == max)
12572     {
12573       printf (_("Unrecognized debug section: %s\n"), print_name);
12574       result = 0;
12575     }
12576
12577   return result;
12578 }
12579
12580 /* Set DUMP_SECTS for all sections where dumps were requested
12581    based on section name.  */
12582
12583 static void
12584 initialise_dumps_byname (void)
12585 {
12586   struct dump_list_entry * cur;
12587
12588   for (cur = dump_sects_byname; cur; cur = cur->next)
12589     {
12590       unsigned int i;
12591       int any;
12592
12593       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12594         if (streq (SECTION_NAME (section_headers + i), cur->name))
12595           {
12596             request_dump_bynumber (i, cur->type);
12597             any = 1;
12598           }
12599
12600       if (!any)
12601         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12602               cur->name);
12603     }
12604 }
12605
12606 static void
12607 process_section_contents (FILE * file)
12608 {
12609   Elf_Internal_Shdr * section;
12610   unsigned int i;
12611
12612   if (! do_dump)
12613     return;
12614
12615   initialise_dumps_byname ();
12616
12617   for (i = 0, section = section_headers;
12618        i < elf_header.e_shnum && i < num_dump_sects;
12619        i++, section++)
12620     {
12621 #ifdef SUPPORT_DISASSEMBLY
12622       if (dump_sects[i] & DISASS_DUMP)
12623         disassemble_section (section, file);
12624 #endif
12625       if (dump_sects[i] & HEX_DUMP)
12626         dump_section_as_bytes (section, file, FALSE);
12627
12628       if (dump_sects[i] & RELOC_DUMP)
12629         dump_section_as_bytes (section, file, TRUE);
12630
12631       if (dump_sects[i] & STRING_DUMP)
12632         dump_section_as_strings (section, file);
12633
12634       if (dump_sects[i] & DEBUG_DUMP)
12635         display_debug_section (i, section, file);
12636     }
12637
12638   /* Check to see if the user requested a
12639      dump of a section that does not exist.  */
12640   while (i++ < num_dump_sects)
12641     if (dump_sects[i])
12642       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12643 }
12644
12645 static void
12646 process_mips_fpe_exception (int mask)
12647 {
12648   if (mask)
12649     {
12650       int first = 1;
12651       if (mask & OEX_FPU_INEX)
12652         fputs ("INEX", stdout), first = 0;
12653       if (mask & OEX_FPU_UFLO)
12654         printf ("%sUFLO", first ? "" : "|"), first = 0;
12655       if (mask & OEX_FPU_OFLO)
12656         printf ("%sOFLO", first ? "" : "|"), first = 0;
12657       if (mask & OEX_FPU_DIV0)
12658         printf ("%sDIV0", first ? "" : "|"), first = 0;
12659       if (mask & OEX_FPU_INVAL)
12660         printf ("%sINVAL", first ? "" : "|");
12661     }
12662   else
12663     fputs ("0", stdout);
12664 }
12665
12666 /* Display's the value of TAG at location P.  If TAG is
12667    greater than 0 it is assumed to be an unknown tag, and
12668    a message is printed to this effect.  Otherwise it is
12669    assumed that a message has already been printed.
12670
12671    If the bottom bit of TAG is set it assumed to have a
12672    string value, otherwise it is assumed to have an integer
12673    value.
12674
12675    Returns an updated P pointing to the first unread byte
12676    beyond the end of TAG's value.
12677
12678    Reads at or beyond END will not be made.  */
12679
12680 static unsigned char *
12681 display_tag_value (int tag,
12682                    unsigned char * p,
12683                    const unsigned char * const end)
12684 {
12685   unsigned long val;
12686
12687   if (tag > 0)
12688     printf ("  Tag_unknown_%d: ", tag);
12689
12690   if (p >= end)
12691     {
12692       warn (_("<corrupt tag>\n"));
12693     }
12694   else if (tag & 1)
12695     {
12696       /* PR 17531 file: 027-19978-0.004.  */
12697       size_t maxlen = (end - p) - 1;
12698
12699       putchar ('"');
12700       if (maxlen > 0)
12701         {
12702           print_symbol ((int) maxlen, (const char *) p);
12703           p += strnlen ((char *) p, maxlen) + 1;
12704         }
12705       else
12706         {
12707           printf (_("<corrupt string tag>"));
12708           p = (unsigned char *) end;
12709         }
12710       printf ("\"\n");
12711     }
12712   else
12713     {
12714       unsigned int len;
12715
12716       val = read_uleb128 (p, &len, end);
12717       p += len;
12718       printf ("%ld (0x%lx)\n", val, val);
12719     }
12720
12721   assert (p <= end);
12722   return p;
12723 }
12724
12725 /* ARM EABI attributes section.  */
12726 typedef struct
12727 {
12728   unsigned int tag;
12729   const char * name;
12730   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12731   unsigned int type;
12732   const char ** table;
12733 } arm_attr_public_tag;
12734
12735 static const char * arm_attr_tag_CPU_arch[] =
12736   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12737    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12738    "v8-M.mainline"};
12739 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12740 static const char * arm_attr_tag_THUMB_ISA_use[] =
12741   {"No", "Thumb-1", "Thumb-2", "Yes"};
12742 static const char * arm_attr_tag_FP_arch[] =
12743   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12744    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12745 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12746 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12747   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12748 static const char * arm_attr_tag_PCS_config[] =
12749   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12750    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12751 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12752   {"V6", "SB", "TLS", "Unused"};
12753 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12754   {"Absolute", "PC-relative", "SB-relative", "None"};
12755 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12756   {"Absolute", "PC-relative", "None"};
12757 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12758   {"None", "direct", "GOT-indirect"};
12759 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12760   {"None", "??? 1", "2", "??? 3", "4"};
12761 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12762 static const char * arm_attr_tag_ABI_FP_denormal[] =
12763   {"Unused", "Needed", "Sign only"};
12764 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12765 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12766 static const char * arm_attr_tag_ABI_FP_number_model[] =
12767   {"Unused", "Finite", "RTABI", "IEEE 754"};
12768 static const char * arm_attr_tag_ABI_enum_size[] =
12769   {"Unused", "small", "int", "forced to int"};
12770 static const char * arm_attr_tag_ABI_HardFP_use[] =
12771   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12772 static const char * arm_attr_tag_ABI_VFP_args[] =
12773   {"AAPCS", "VFP registers", "custom", "compatible"};
12774 static const char * arm_attr_tag_ABI_WMMX_args[] =
12775   {"AAPCS", "WMMX registers", "custom"};
12776 static const char * arm_attr_tag_ABI_optimization_goals[] =
12777   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12778     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12779 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12780   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12781     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12782 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12783 static const char * arm_attr_tag_FP_HP_extension[] =
12784   {"Not Allowed", "Allowed"};
12785 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12786   {"None", "IEEE 754", "Alternative Format"};
12787 static const char * arm_attr_tag_MPextension_use[] =
12788   {"Not Allowed", "Allowed"};
12789 static const char * arm_attr_tag_DIV_use[] =
12790   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12791     "Allowed in v7-A with integer division extension"};
12792 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12793 static const char * arm_attr_tag_Virtualization_use[] =
12794   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12795     "TrustZone and Virtualization Extensions"};
12796 static const char * arm_attr_tag_MPextension_use_legacy[] =
12797   {"Not Allowed", "Allowed"};
12798
12799 #define LOOKUP(id, name) \
12800   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12801 static arm_attr_public_tag arm_attr_public_tags[] =
12802 {
12803   {4, "CPU_raw_name", 1, NULL},
12804   {5, "CPU_name", 1, NULL},
12805   LOOKUP(6, CPU_arch),
12806   {7, "CPU_arch_profile", 0, NULL},
12807   LOOKUP(8, ARM_ISA_use),
12808   LOOKUP(9, THUMB_ISA_use),
12809   LOOKUP(10, FP_arch),
12810   LOOKUP(11, WMMX_arch),
12811   LOOKUP(12, Advanced_SIMD_arch),
12812   LOOKUP(13, PCS_config),
12813   LOOKUP(14, ABI_PCS_R9_use),
12814   LOOKUP(15, ABI_PCS_RW_data),
12815   LOOKUP(16, ABI_PCS_RO_data),
12816   LOOKUP(17, ABI_PCS_GOT_use),
12817   LOOKUP(18, ABI_PCS_wchar_t),
12818   LOOKUP(19, ABI_FP_rounding),
12819   LOOKUP(20, ABI_FP_denormal),
12820   LOOKUP(21, ABI_FP_exceptions),
12821   LOOKUP(22, ABI_FP_user_exceptions),
12822   LOOKUP(23, ABI_FP_number_model),
12823   {24, "ABI_align_needed", 0, NULL},
12824   {25, "ABI_align_preserved", 0, NULL},
12825   LOOKUP(26, ABI_enum_size),
12826   LOOKUP(27, ABI_HardFP_use),
12827   LOOKUP(28, ABI_VFP_args),
12828   LOOKUP(29, ABI_WMMX_args),
12829   LOOKUP(30, ABI_optimization_goals),
12830   LOOKUP(31, ABI_FP_optimization_goals),
12831   {32, "compatibility", 0, NULL},
12832   LOOKUP(34, CPU_unaligned_access),
12833   LOOKUP(36, FP_HP_extension),
12834   LOOKUP(38, ABI_FP_16bit_format),
12835   LOOKUP(42, MPextension_use),
12836   LOOKUP(44, DIV_use),
12837   {64, "nodefaults", 0, NULL},
12838   {65, "also_compatible_with", 0, NULL},
12839   LOOKUP(66, T2EE_use),
12840   {67, "conformance", 1, NULL},
12841   LOOKUP(68, Virtualization_use),
12842   LOOKUP(70, MPextension_use_legacy)
12843 };
12844 #undef LOOKUP
12845
12846 static unsigned char *
12847 display_arm_attribute (unsigned char * p,
12848                        const unsigned char * const end)
12849 {
12850   unsigned int tag;
12851   unsigned int len;
12852   unsigned int val;
12853   arm_attr_public_tag * attr;
12854   unsigned i;
12855   unsigned int type;
12856
12857   tag = read_uleb128 (p, &len, end);
12858   p += len;
12859   attr = NULL;
12860   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12861     {
12862       if (arm_attr_public_tags[i].tag == tag)
12863         {
12864           attr = &arm_attr_public_tags[i];
12865           break;
12866         }
12867     }
12868
12869   if (attr)
12870     {
12871       printf ("  Tag_%s: ", attr->name);
12872       switch (attr->type)
12873         {
12874         case 0:
12875           switch (tag)
12876             {
12877             case 7: /* Tag_CPU_arch_profile.  */
12878               val = read_uleb128 (p, &len, end);
12879               p += len;
12880               switch (val)
12881                 {
12882                 case 0: printf (_("None\n")); break;
12883                 case 'A': printf (_("Application\n")); break;
12884                 case 'R': printf (_("Realtime\n")); break;
12885                 case 'M': printf (_("Microcontroller\n")); break;
12886                 case 'S': printf (_("Application or Realtime\n")); break;
12887                 default: printf ("??? (%d)\n", val); break;
12888                 }
12889               break;
12890
12891             case 24: /* Tag_align_needed.  */
12892               val = read_uleb128 (p, &len, end);
12893               p += len;
12894               switch (val)
12895                 {
12896                 case 0: printf (_("None\n")); break;
12897                 case 1: printf (_("8-byte\n")); break;
12898                 case 2: printf (_("4-byte\n")); break;
12899                 case 3: printf ("??? 3\n"); break;
12900                 default:
12901                   if (val <= 12)
12902                     printf (_("8-byte and up to %d-byte extended\n"),
12903                             1 << val);
12904                   else
12905                     printf ("??? (%d)\n", val);
12906                   break;
12907                 }
12908               break;
12909
12910             case 25: /* Tag_align_preserved.  */
12911               val = read_uleb128 (p, &len, end);
12912               p += len;
12913               switch (val)
12914                 {
12915                 case 0: printf (_("None\n")); break;
12916                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12917                 case 2: printf (_("8-byte\n")); break;
12918                 case 3: printf ("??? 3\n"); break;
12919                 default:
12920                   if (val <= 12)
12921                     printf (_("8-byte and up to %d-byte extended\n"),
12922                             1 << val);
12923                   else
12924                     printf ("??? (%d)\n", val);
12925                   break;
12926                 }
12927               break;
12928
12929             case 32: /* Tag_compatibility.  */
12930               {
12931                 val = read_uleb128 (p, &len, end);
12932                 p += len;
12933                 printf (_("flag = %d, vendor = "), val);
12934                 if (p < end - 1)
12935                   {
12936                     size_t maxlen = (end - p) - 1;
12937
12938                     print_symbol ((int) maxlen, (const char *) p);
12939                     p += strnlen ((char *) p, maxlen) + 1;
12940                   }
12941                 else
12942                   {
12943                     printf (_("<corrupt>"));
12944                     p = (unsigned char *) end;
12945                   }
12946                 putchar ('\n');
12947               }
12948               break;
12949
12950             case 64: /* Tag_nodefaults.  */
12951               /* PR 17531: file: 001-505008-0.01.  */
12952               if (p < end)
12953                 p++;
12954               printf (_("True\n"));
12955               break;
12956
12957             case 65: /* Tag_also_compatible_with.  */
12958               val = read_uleb128 (p, &len, end);
12959               p += len;
12960               if (val == 6 /* Tag_CPU_arch.  */)
12961                 {
12962                   val = read_uleb128 (p, &len, end);
12963                   p += len;
12964                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12965                     printf ("??? (%d)\n", val);
12966                   else
12967                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12968                 }
12969               else
12970                 printf ("???\n");
12971               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12972                 ;
12973               break;
12974
12975             default:
12976               printf (_("<unknown: %d>\n"), tag);
12977               break;
12978             }
12979           return p;
12980
12981         case 1:
12982           return display_tag_value (-1, p, end);
12983         case 2:
12984           return display_tag_value (0, p, end);
12985
12986         default:
12987           assert (attr->type & 0x80);
12988           val = read_uleb128 (p, &len, end);
12989           p += len;
12990           type = attr->type & 0x7f;
12991           if (val >= type)
12992             printf ("??? (%d)\n", val);
12993           else
12994             printf ("%s\n", attr->table[val]);
12995           return p;
12996         }
12997     }
12998
12999   return display_tag_value (tag, p, end);
13000 }
13001
13002 static unsigned char *
13003 display_gnu_attribute (unsigned char * p,
13004                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13005                        const unsigned char * const end)
13006 {
13007   int tag;
13008   unsigned int len;
13009   int val;
13010
13011   tag = read_uleb128 (p, &len, end);
13012   p += len;
13013
13014   /* Tag_compatibility is the only generic GNU attribute defined at
13015      present.  */
13016   if (tag == 32)
13017     {
13018       val = read_uleb128 (p, &len, end);
13019       p += len;
13020
13021       printf (_("flag = %d, vendor = "), val);
13022       if (p == end)
13023         {
13024           printf (_("<corrupt>\n"));
13025           warn (_("corrupt vendor attribute\n"));
13026         }
13027       else
13028         {
13029           if (p < end - 1)
13030             {
13031               size_t maxlen = (end - p) - 1;
13032
13033               print_symbol ((int) maxlen, (const char *) p);
13034               p += strnlen ((char *) p, maxlen) + 1;
13035             }
13036           else
13037             {
13038               printf (_("<corrupt>"));
13039               p = (unsigned char *) end;
13040             }
13041           putchar ('\n');
13042         }
13043       return p;
13044     }
13045
13046   if ((tag & 2) == 0 && display_proc_gnu_attribute)
13047     return display_proc_gnu_attribute (p, tag, end);
13048
13049   return display_tag_value (tag, p, end);
13050 }
13051
13052 static unsigned char *
13053 display_power_gnu_attribute (unsigned char * p,
13054                              int tag,
13055                              const unsigned char * const end)
13056 {
13057   unsigned int len;
13058   int val;
13059
13060   if (tag == Tag_GNU_Power_ABI_FP)
13061     {
13062       val = read_uleb128 (p, &len, end);
13063       p += len;
13064       printf ("  Tag_GNU_Power_ABI_FP: ");
13065
13066       switch (val)
13067         {
13068         case 0:
13069           printf (_("Hard or soft float\n"));
13070           break;
13071         case 1:
13072           printf (_("Hard float\n"));
13073           break;
13074         case 2:
13075           printf (_("Soft float\n"));
13076           break;
13077         case 3:
13078           printf (_("Single-precision hard float\n"));
13079           break;
13080         default:
13081           printf ("??? (%d)\n", val);
13082           break;
13083         }
13084       return p;
13085    }
13086
13087   if (tag == Tag_GNU_Power_ABI_Vector)
13088     {
13089       val = read_uleb128 (p, &len, end);
13090       p += len;
13091       printf ("  Tag_GNU_Power_ABI_Vector: ");
13092       switch (val)
13093         {
13094         case 0:
13095           printf (_("Any\n"));
13096           break;
13097         case 1:
13098           printf (_("Generic\n"));
13099           break;
13100         case 2:
13101           printf ("AltiVec\n");
13102           break;
13103         case 3:
13104           printf ("SPE\n");
13105           break;
13106         default:
13107           printf ("??? (%d)\n", val);
13108           break;
13109         }
13110       return p;
13111    }
13112
13113   if (tag == Tag_GNU_Power_ABI_Struct_Return)
13114     {
13115       if (p == end)
13116         {
13117           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13118           return p;
13119         }
13120
13121       val = read_uleb128 (p, &len, end);
13122       p += len;
13123       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13124       switch (val)
13125        {
13126        case 0:
13127          printf (_("Any\n"));
13128          break;
13129        case 1:
13130          printf ("r3/r4\n");
13131          break;
13132        case 2:
13133          printf (_("Memory\n"));
13134          break;
13135        default:
13136          printf ("??? (%d)\n", val);
13137          break;
13138        }
13139       return p;
13140     }
13141
13142   return display_tag_value (tag & 1, p, end);
13143 }
13144
13145 static unsigned char *
13146 display_s390_gnu_attribute (unsigned char * p,
13147                             int tag,
13148                             const unsigned char * const end)
13149 {
13150   unsigned int len;
13151   int val;
13152
13153   if (tag == Tag_GNU_S390_ABI_Vector)
13154     {
13155       val = read_uleb128 (p, &len, end);
13156       p += len;
13157       printf ("  Tag_GNU_S390_ABI_Vector: ");
13158
13159       switch (val)
13160         {
13161         case 0:
13162           printf (_("any\n"));
13163           break;
13164         case 1:
13165           printf (_("software\n"));
13166           break;
13167         case 2:
13168           printf (_("hardware\n"));
13169           break;
13170         default:
13171           printf ("??? (%d)\n", val);
13172           break;
13173         }
13174       return p;
13175    }
13176
13177   return display_tag_value (tag & 1, p, end);
13178 }
13179
13180 static void
13181 display_sparc_hwcaps (int mask)
13182 {
13183   if (mask)
13184     {
13185       int first = 1;
13186
13187       if (mask & ELF_SPARC_HWCAP_MUL32)
13188         fputs ("mul32", stdout), first = 0;
13189       if (mask & ELF_SPARC_HWCAP_DIV32)
13190         printf ("%sdiv32", first ? "" : "|"), first = 0;
13191       if (mask & ELF_SPARC_HWCAP_FSMULD)
13192         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13193       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13194         printf ("%sv8plus", first ? "" : "|"), first = 0;
13195       if (mask & ELF_SPARC_HWCAP_POPC)
13196         printf ("%spopc", first ? "" : "|"), first = 0;
13197       if (mask & ELF_SPARC_HWCAP_VIS)
13198         printf ("%svis", first ? "" : "|"), first = 0;
13199       if (mask & ELF_SPARC_HWCAP_VIS2)
13200         printf ("%svis2", first ? "" : "|"), first = 0;
13201       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13202         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13203       if (mask & ELF_SPARC_HWCAP_FMAF)
13204         printf ("%sfmaf", first ? "" : "|"), first = 0;
13205       if (mask & ELF_SPARC_HWCAP_VIS3)
13206         printf ("%svis3", first ? "" : "|"), first = 0;
13207       if (mask & ELF_SPARC_HWCAP_HPC)
13208         printf ("%shpc", first ? "" : "|"), first = 0;
13209       if (mask & ELF_SPARC_HWCAP_RANDOM)
13210         printf ("%srandom", first ? "" : "|"), first = 0;
13211       if (mask & ELF_SPARC_HWCAP_TRANS)
13212         printf ("%strans", first ? "" : "|"), first = 0;
13213       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13214         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13215       if (mask & ELF_SPARC_HWCAP_IMA)
13216         printf ("%sima", first ? "" : "|"), first = 0;
13217       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13218         printf ("%scspare", first ? "" : "|"), first = 0;
13219     }
13220   else
13221     fputc ('0', stdout);
13222   fputc ('\n', stdout);
13223 }
13224
13225 static void
13226 display_sparc_hwcaps2 (int mask)
13227 {
13228   if (mask)
13229     {
13230       int first = 1;
13231
13232       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13233         fputs ("fjathplus", stdout), first = 0;
13234       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13235         printf ("%svis3b", first ? "" : "|"), first = 0;
13236       if (mask & ELF_SPARC_HWCAP2_ADP)
13237         printf ("%sadp", first ? "" : "|"), first = 0;
13238       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13239         printf ("%ssparc5", first ? "" : "|"), first = 0;
13240       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13241         printf ("%smwait", first ? "" : "|"), first = 0;
13242       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13243         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13244       if (mask & ELF_SPARC_HWCAP2_XMONT)
13245         printf ("%sxmont2", first ? "" : "|"), first = 0;
13246       if (mask & ELF_SPARC_HWCAP2_NSEC)
13247         printf ("%snsec", first ? "" : "|"), first = 0;
13248       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13249         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13250       if (mask & ELF_SPARC_HWCAP2_FJDES)
13251         printf ("%sfjdes", first ? "" : "|"), first = 0;
13252       if (mask & ELF_SPARC_HWCAP2_FJAES)
13253         printf ("%sfjaes", first ? "" : "|"), first = 0;
13254     }
13255   else
13256     fputc ('0', stdout);
13257   fputc ('\n', stdout);
13258 }
13259
13260 static unsigned char *
13261 display_sparc_gnu_attribute (unsigned char * p,
13262                              int tag,
13263                              const unsigned char * const end)
13264 {
13265   unsigned int len;
13266   int val;
13267
13268   if (tag == Tag_GNU_Sparc_HWCAPS)
13269     {
13270       val = read_uleb128 (p, &len, end);
13271       p += len;
13272       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13273       display_sparc_hwcaps (val);
13274       return p;
13275     }
13276   if (tag == Tag_GNU_Sparc_HWCAPS2)
13277     {
13278       val = read_uleb128 (p, &len, end);
13279       p += len;
13280       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13281       display_sparc_hwcaps2 (val);
13282       return p;
13283     }
13284
13285   return display_tag_value (tag, p, end);
13286 }
13287
13288 static void
13289 print_mips_fp_abi_value (int val)
13290 {
13291   switch (val)
13292     {
13293     case Val_GNU_MIPS_ABI_FP_ANY:
13294       printf (_("Hard or soft float\n"));
13295       break;
13296     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13297       printf (_("Hard float (double precision)\n"));
13298       break;
13299     case Val_GNU_MIPS_ABI_FP_SINGLE:
13300       printf (_("Hard float (single precision)\n"));
13301       break;
13302     case Val_GNU_MIPS_ABI_FP_SOFT:
13303       printf (_("Soft float\n"));
13304       break;
13305     case Val_GNU_MIPS_ABI_FP_OLD_64:
13306       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13307       break;
13308     case Val_GNU_MIPS_ABI_FP_XX:
13309       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13310       break;
13311     case Val_GNU_MIPS_ABI_FP_64:
13312       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13313       break;
13314     case Val_GNU_MIPS_ABI_FP_64A:
13315       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13316       break;
13317     case Val_GNU_MIPS_ABI_FP_NAN2008:
13318       printf (_("NaN 2008 compatibility\n"));
13319       break;
13320     default:
13321       printf ("??? (%d)\n", val);
13322       break;
13323     }
13324 }
13325
13326 static unsigned char *
13327 display_mips_gnu_attribute (unsigned char * p,
13328                             int tag,
13329                             const unsigned char * const end)
13330 {
13331   if (tag == Tag_GNU_MIPS_ABI_FP)
13332     {
13333       unsigned int len;
13334       int val;
13335
13336       val = read_uleb128 (p, &len, end);
13337       p += len;
13338       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13339
13340       print_mips_fp_abi_value (val);
13341
13342       return p;
13343    }
13344
13345   if (tag == Tag_GNU_MIPS_ABI_MSA)
13346     {
13347       unsigned int len;
13348       int val;
13349
13350       val = read_uleb128 (p, &len, end);
13351       p += len;
13352       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13353
13354       switch (val)
13355         {
13356         case Val_GNU_MIPS_ABI_MSA_ANY:
13357           printf (_("Any MSA or not\n"));
13358           break;
13359         case Val_GNU_MIPS_ABI_MSA_128:
13360           printf (_("128-bit MSA\n"));
13361           break;
13362         default:
13363           printf ("??? (%d)\n", val);
13364           break;
13365         }
13366       return p;
13367     }
13368
13369   return display_tag_value (tag & 1, p, end);
13370 }
13371
13372 static unsigned char *
13373 display_tic6x_attribute (unsigned char * p,
13374                          const unsigned char * const end)
13375 {
13376   int tag;
13377   unsigned int len;
13378   int val;
13379
13380   tag = read_uleb128 (p, &len, end);
13381   p += len;
13382
13383   switch (tag)
13384     {
13385     case Tag_ISA:
13386       val = read_uleb128 (p, &len, end);
13387       p += len;
13388       printf ("  Tag_ISA: ");
13389
13390       switch (val)
13391         {
13392         case C6XABI_Tag_ISA_none:
13393           printf (_("None\n"));
13394           break;
13395         case C6XABI_Tag_ISA_C62X:
13396           printf ("C62x\n");
13397           break;
13398         case C6XABI_Tag_ISA_C67X:
13399           printf ("C67x\n");
13400           break;
13401         case C6XABI_Tag_ISA_C67XP:
13402           printf ("C67x+\n");
13403           break;
13404         case C6XABI_Tag_ISA_C64X:
13405           printf ("C64x\n");
13406           break;
13407         case C6XABI_Tag_ISA_C64XP:
13408           printf ("C64x+\n");
13409           break;
13410         case C6XABI_Tag_ISA_C674X:
13411           printf ("C674x\n");
13412           break;
13413         default:
13414           printf ("??? (%d)\n", val);
13415           break;
13416         }
13417       return p;
13418
13419     case Tag_ABI_wchar_t:
13420       val = read_uleb128 (p, &len, end);
13421       p += len;
13422       printf ("  Tag_ABI_wchar_t: ");
13423       switch (val)
13424         {
13425         case 0:
13426           printf (_("Not used\n"));
13427           break;
13428         case 1:
13429           printf (_("2 bytes\n"));
13430           break;
13431         case 2:
13432           printf (_("4 bytes\n"));
13433           break;
13434         default:
13435           printf ("??? (%d)\n", val);
13436           break;
13437         }
13438       return p;
13439
13440     case Tag_ABI_stack_align_needed:
13441       val = read_uleb128 (p, &len, end);
13442       p += len;
13443       printf ("  Tag_ABI_stack_align_needed: ");
13444       switch (val)
13445         {
13446         case 0:
13447           printf (_("8-byte\n"));
13448           break;
13449         case 1:
13450           printf (_("16-byte\n"));
13451           break;
13452         default:
13453           printf ("??? (%d)\n", val);
13454           break;
13455         }
13456       return p;
13457
13458     case Tag_ABI_stack_align_preserved:
13459       val = read_uleb128 (p, &len, end);
13460       p += len;
13461       printf ("  Tag_ABI_stack_align_preserved: ");
13462       switch (val)
13463         {
13464         case 0:
13465           printf (_("8-byte\n"));
13466           break;
13467         case 1:
13468           printf (_("16-byte\n"));
13469           break;
13470         default:
13471           printf ("??? (%d)\n", val);
13472           break;
13473         }
13474       return p;
13475
13476     case Tag_ABI_DSBT:
13477       val = read_uleb128 (p, &len, end);
13478       p += len;
13479       printf ("  Tag_ABI_DSBT: ");
13480       switch (val)
13481         {
13482         case 0:
13483           printf (_("DSBT addressing not used\n"));
13484           break;
13485         case 1:
13486           printf (_("DSBT addressing used\n"));
13487           break;
13488         default:
13489           printf ("??? (%d)\n", val);
13490           break;
13491         }
13492       return p;
13493
13494     case Tag_ABI_PID:
13495       val = read_uleb128 (p, &len, end);
13496       p += len;
13497       printf ("  Tag_ABI_PID: ");
13498       switch (val)
13499         {
13500         case 0:
13501           printf (_("Data addressing position-dependent\n"));
13502           break;
13503         case 1:
13504           printf (_("Data addressing position-independent, GOT near DP\n"));
13505           break;
13506         case 2:
13507           printf (_("Data addressing position-independent, GOT far from DP\n"));
13508           break;
13509         default:
13510           printf ("??? (%d)\n", val);
13511           break;
13512         }
13513       return p;
13514
13515     case Tag_ABI_PIC:
13516       val = read_uleb128 (p, &len, end);
13517       p += len;
13518       printf ("  Tag_ABI_PIC: ");
13519       switch (val)
13520         {
13521         case 0:
13522           printf (_("Code addressing position-dependent\n"));
13523           break;
13524         case 1:
13525           printf (_("Code addressing position-independent\n"));
13526           break;
13527         default:
13528           printf ("??? (%d)\n", val);
13529           break;
13530         }
13531       return p;
13532
13533     case Tag_ABI_array_object_alignment:
13534       val = read_uleb128 (p, &len, end);
13535       p += len;
13536       printf ("  Tag_ABI_array_object_alignment: ");
13537       switch (val)
13538         {
13539         case 0:
13540           printf (_("8-byte\n"));
13541           break;
13542         case 1:
13543           printf (_("4-byte\n"));
13544           break;
13545         case 2:
13546           printf (_("16-byte\n"));
13547           break;
13548         default:
13549           printf ("??? (%d)\n", val);
13550           break;
13551         }
13552       return p;
13553
13554     case Tag_ABI_array_object_align_expected:
13555       val = read_uleb128 (p, &len, end);
13556       p += len;
13557       printf ("  Tag_ABI_array_object_align_expected: ");
13558       switch (val)
13559         {
13560         case 0:
13561           printf (_("8-byte\n"));
13562           break;
13563         case 1:
13564           printf (_("4-byte\n"));
13565           break;
13566         case 2:
13567           printf (_("16-byte\n"));
13568           break;
13569         default:
13570           printf ("??? (%d)\n", val);
13571           break;
13572         }
13573       return p;
13574
13575     case Tag_ABI_compatibility:
13576       {
13577         val = read_uleb128 (p, &len, end);
13578         p += len;
13579         printf ("  Tag_ABI_compatibility: ");
13580         printf (_("flag = %d, vendor = "), val);
13581         if (p < end - 1)
13582           {
13583             size_t maxlen = (end - p) - 1;
13584
13585             print_symbol ((int) maxlen, (const char *) p);
13586             p += strnlen ((char *) p, maxlen) + 1;
13587           }
13588         else
13589           {
13590             printf (_("<corrupt>"));
13591             p = (unsigned char *) end;
13592           }
13593         putchar ('\n');
13594         return p;
13595       }
13596
13597     case Tag_ABI_conformance:
13598       {
13599         printf ("  Tag_ABI_conformance: \"");
13600         if (p < end - 1)
13601           {
13602             size_t maxlen = (end - p) - 1;
13603
13604             print_symbol ((int) maxlen, (const char *) p);
13605             p += strnlen ((char *) p, maxlen) + 1;
13606           }
13607         else
13608           {
13609             printf (_("<corrupt>"));
13610             p = (unsigned char *) end;
13611           }
13612         printf ("\"\n");
13613         return p;
13614       }
13615     }
13616
13617   return display_tag_value (tag, p, end);
13618 }
13619
13620 static void
13621 display_raw_attribute (unsigned char * p, unsigned char * end)
13622 {
13623   unsigned long addr = 0;
13624   size_t bytes = end - p;
13625
13626   assert (end > p);
13627   while (bytes)
13628     {
13629       int j;
13630       int k;
13631       int lbytes = (bytes > 16 ? 16 : bytes);
13632
13633       printf ("  0x%8.8lx ", addr);
13634
13635       for (j = 0; j < 16; j++)
13636         {
13637           if (j < lbytes)
13638             printf ("%2.2x", p[j]);
13639           else
13640             printf ("  ");
13641
13642           if ((j & 3) == 3)
13643             printf (" ");
13644         }
13645
13646       for (j = 0; j < lbytes; j++)
13647         {
13648           k = p[j];
13649           if (k >= ' ' && k < 0x7f)
13650             printf ("%c", k);
13651           else
13652             printf (".");
13653         }
13654
13655       putchar ('\n');
13656
13657       p  += lbytes;
13658       bytes -= lbytes;
13659       addr += lbytes;
13660     }
13661
13662   putchar ('\n');
13663 }
13664
13665 static unsigned char *
13666 display_msp430x_attribute (unsigned char * p,
13667                            const unsigned char * const end)
13668 {
13669   unsigned int len;
13670   int val;
13671   int tag;
13672
13673   tag = read_uleb128 (p, & len, end);
13674   p += len;
13675
13676   switch (tag)
13677     {
13678     case OFBA_MSPABI_Tag_ISA:
13679       val = read_uleb128 (p, &len, end);
13680       p += len;
13681       printf ("  Tag_ISA: ");
13682       switch (val)
13683         {
13684         case 0: printf (_("None\n")); break;
13685         case 1: printf (_("MSP430\n")); break;
13686         case 2: printf (_("MSP430X\n")); break;
13687         default: printf ("??? (%d)\n", val); break;
13688         }
13689       break;
13690
13691     case OFBA_MSPABI_Tag_Code_Model:
13692       val = read_uleb128 (p, &len, end);
13693       p += len;
13694       printf ("  Tag_Code_Model: ");
13695       switch (val)
13696         {
13697         case 0: printf (_("None\n")); break;
13698         case 1: printf (_("Small\n")); break;
13699         case 2: printf (_("Large\n")); break;
13700         default: printf ("??? (%d)\n", val); break;
13701         }
13702       break;
13703
13704     case OFBA_MSPABI_Tag_Data_Model:
13705       val = read_uleb128 (p, &len, end);
13706       p += len;
13707       printf ("  Tag_Data_Model: ");
13708       switch (val)
13709         {
13710         case 0: printf (_("None\n")); break;
13711         case 1: printf (_("Small\n")); break;
13712         case 2: printf (_("Large\n")); break;
13713         case 3: printf (_("Restricted Large\n")); break;
13714         default: printf ("??? (%d)\n", val); break;
13715         }
13716       break;
13717
13718     default:
13719       printf (_("  <unknown tag %d>: "), tag);
13720
13721       if (tag & 1)
13722         {
13723           putchar ('"');
13724           if (p < end - 1)
13725             {
13726               size_t maxlen = (end - p) - 1;
13727
13728               print_symbol ((int) maxlen, (const char *) p);
13729               p += strnlen ((char *) p, maxlen) + 1;
13730             }
13731           else
13732             {
13733               printf (_("<corrupt>"));
13734               p = (unsigned char *) end;
13735             }
13736           printf ("\"\n");
13737         }
13738       else
13739         {
13740           val = read_uleb128 (p, &len, end);
13741           p += len;
13742           printf ("%d (0x%x)\n", val, val);
13743         }
13744       break;
13745    }
13746
13747   assert (p <= end);
13748   return p;
13749 }
13750
13751 static int
13752 process_attributes (FILE * file,
13753                     const char * public_name,
13754                     unsigned int proc_type,
13755                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13756                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13757 {
13758   Elf_Internal_Shdr * sect;
13759   unsigned i;
13760
13761   /* Find the section header so that we get the size.  */
13762   for (i = 0, sect = section_headers;
13763        i < elf_header.e_shnum;
13764        i++, sect++)
13765     {
13766       unsigned char * contents;
13767       unsigned char * p;
13768
13769       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13770         continue;
13771
13772       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13773                                              sect->sh_size, _("attributes"));
13774       if (contents == NULL)
13775         continue;
13776
13777       p = contents;
13778       if (*p == 'A')
13779         {
13780           bfd_vma section_len;
13781
13782           section_len = sect->sh_size - 1;
13783           p++;
13784
13785           while (section_len > 0)
13786             {
13787               bfd_vma attr_len;
13788               unsigned int namelen;
13789               bfd_boolean public_section;
13790               bfd_boolean gnu_section;
13791
13792               if (section_len <= 4)
13793                 {
13794                   error (_("Tag section ends prematurely\n"));
13795                   break;
13796                 }
13797               attr_len = byte_get (p, 4);
13798               p += 4;
13799
13800               if (attr_len > section_len)
13801                 {
13802                   error (_("Bad attribute length (%u > %u)\n"),
13803                           (unsigned) attr_len, (unsigned) section_len);
13804                   attr_len = section_len;
13805                 }
13806               /* PR 17531: file: 001-101425-0.004  */
13807               else if (attr_len < 5)
13808                 {
13809                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13810                   break;
13811                 }
13812
13813               section_len -= attr_len;
13814               attr_len -= 4;
13815
13816               namelen = strnlen ((char *) p, attr_len) + 1;
13817               if (namelen == 0 || namelen >= attr_len)
13818                 {
13819                   error (_("Corrupt attribute section name\n"));
13820                   break;
13821                 }
13822
13823               printf (_("Attribute Section: "));
13824               print_symbol (INT_MAX, (const char *) p);
13825               putchar ('\n');
13826
13827               if (public_name && streq ((char *) p, public_name))
13828                 public_section = TRUE;
13829               else
13830                 public_section = FALSE;
13831
13832               if (streq ((char *) p, "gnu"))
13833                 gnu_section = TRUE;
13834               else
13835                 gnu_section = FALSE;
13836
13837               p += namelen;
13838               attr_len -= namelen;
13839
13840               while (attr_len > 0 && p < contents + sect->sh_size)
13841                 {
13842                   int tag;
13843                   int val;
13844                   bfd_vma size;
13845                   unsigned char * end;
13846
13847                   /* PR binutils/17531: Safe handling of corrupt files.  */
13848                   if (attr_len < 6)
13849                     {
13850                       error (_("Unused bytes at end of section\n"));
13851                       section_len = 0;
13852                       break;
13853                     }
13854
13855                   tag = *(p++);
13856                   size = byte_get (p, 4);
13857                   if (size > attr_len)
13858                     {
13859                       error (_("Bad subsection length (%u > %u)\n"),
13860                               (unsigned) size, (unsigned) attr_len);
13861                       size = attr_len;
13862                     }
13863                   /* PR binutils/17531: Safe handling of corrupt files.  */
13864                   if (size < 6)
13865                     {
13866                       error (_("Bad subsection length (%u < 6)\n"),
13867                               (unsigned) size);
13868                       section_len = 0;
13869                       break;
13870                     }
13871
13872                   attr_len -= size;
13873                   end = p + size - 1;
13874                   assert (end <= contents + sect->sh_size);
13875                   p += 4;
13876
13877                   switch (tag)
13878                     {
13879                     case 1:
13880                       printf (_("File Attributes\n"));
13881                       break;
13882                     case 2:
13883                       printf (_("Section Attributes:"));
13884                       goto do_numlist;
13885                     case 3:
13886                       printf (_("Symbol Attributes:"));
13887                     do_numlist:
13888                       for (;;)
13889                         {
13890                           unsigned int j;
13891
13892                           val = read_uleb128 (p, &j, end);
13893                           p += j;
13894                           if (val == 0)
13895                             break;
13896                           printf (" %d", val);
13897                         }
13898                       printf ("\n");
13899                       break;
13900                     default:
13901                       printf (_("Unknown tag: %d\n"), tag);
13902                       public_section = FALSE;
13903                       break;
13904                     }
13905
13906                   if (public_section && display_pub_attribute != NULL)
13907                     {
13908                       while (p < end)
13909                         p = display_pub_attribute (p, end);
13910                       assert (p <= end);
13911                     }
13912                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13913                     {
13914                       while (p < end)
13915                         p = display_gnu_attribute (p,
13916                                                    display_proc_gnu_attribute,
13917                                                    end);
13918                       assert (p <= end);
13919                     }
13920                   else if (p < end)
13921                     {
13922                       printf (_("  Unknown attribute:\n"));
13923                       display_raw_attribute (p, end);
13924                       p = end;
13925                     }
13926                   else
13927                     attr_len = 0;
13928                 }
13929             }
13930         }
13931       else
13932         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13933
13934       free (contents);
13935     }
13936   return 1;
13937 }
13938
13939 static int
13940 process_arm_specific (FILE * file)
13941 {
13942   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13943                              display_arm_attribute, NULL);
13944 }
13945
13946 static int
13947 process_power_specific (FILE * file)
13948 {
13949   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13950                              display_power_gnu_attribute);
13951 }
13952
13953 static int
13954 process_s390_specific (FILE * file)
13955 {
13956   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13957                              display_s390_gnu_attribute);
13958 }
13959
13960 static int
13961 process_sparc_specific (FILE * file)
13962 {
13963   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13964                              display_sparc_gnu_attribute);
13965 }
13966
13967 static int
13968 process_tic6x_specific (FILE * file)
13969 {
13970   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13971                              display_tic6x_attribute, NULL);
13972 }
13973
13974 static int
13975 process_msp430x_specific (FILE * file)
13976 {
13977   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13978                              display_msp430x_attribute, NULL);
13979 }
13980
13981 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13982    Print the Address, Access and Initial fields of an entry at VMA ADDR
13983    and return the VMA of the next entry, or -1 if there was a problem.
13984    Does not read from DATA_END or beyond.  */
13985
13986 static bfd_vma
13987 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13988                       unsigned char * data_end)
13989 {
13990   printf ("  ");
13991   print_vma (addr, LONG_HEX);
13992   printf (" ");
13993   if (addr < pltgot + 0xfff0)
13994     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13995   else
13996     printf ("%10s", "");
13997   printf (" ");
13998   if (data == NULL)
13999     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14000   else
14001     {
14002       bfd_vma entry;
14003       unsigned char * from = data + addr - pltgot;
14004
14005       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14006         {
14007           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14008           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14009           return (bfd_vma) -1;
14010         }
14011       else
14012         {
14013           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14014           print_vma (entry, LONG_HEX);
14015         }
14016     }
14017   return addr + (is_32bit_elf ? 4 : 8);
14018 }
14019
14020 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14021    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14022    ADDR and return the VMA of the next entry.  */
14023
14024 static bfd_vma
14025 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14026 {
14027   printf ("  ");
14028   print_vma (addr, LONG_HEX);
14029   printf (" ");
14030   if (data == NULL)
14031     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14032   else
14033     {
14034       bfd_vma entry;
14035
14036       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14037       print_vma (entry, LONG_HEX);
14038     }
14039   return addr + (is_32bit_elf ? 4 : 8);
14040 }
14041
14042 static void
14043 print_mips_ases (unsigned int mask)
14044 {
14045   if (mask & AFL_ASE_DSP)
14046     fputs ("\n\tDSP ASE", stdout);
14047   if (mask & AFL_ASE_DSPR2)
14048     fputs ("\n\tDSP R2 ASE", stdout);
14049   if (mask & AFL_ASE_EVA)
14050     fputs ("\n\tEnhanced VA Scheme", stdout);
14051   if (mask & AFL_ASE_MCU)
14052     fputs ("\n\tMCU (MicroController) ASE", stdout);
14053   if (mask & AFL_ASE_MDMX)
14054     fputs ("\n\tMDMX ASE", stdout);
14055   if (mask & AFL_ASE_MIPS3D)
14056     fputs ("\n\tMIPS-3D ASE", stdout);
14057   if (mask & AFL_ASE_MT)
14058     fputs ("\n\tMT ASE", stdout);
14059   if (mask & AFL_ASE_SMARTMIPS)
14060     fputs ("\n\tSmartMIPS ASE", stdout);
14061   if (mask & AFL_ASE_VIRT)
14062     fputs ("\n\tVZ ASE", stdout);
14063   if (mask & AFL_ASE_MSA)
14064     fputs ("\n\tMSA ASE", stdout);
14065   if (mask & AFL_ASE_MIPS16)
14066     fputs ("\n\tMIPS16 ASE", stdout);
14067   if (mask & AFL_ASE_MICROMIPS)
14068     fputs ("\n\tMICROMIPS ASE", stdout);
14069   if (mask & AFL_ASE_XPA)
14070     fputs ("\n\tXPA ASE", stdout);
14071   if (mask == 0)
14072     fprintf (stdout, "\n\t%s", _("None"));
14073   else if ((mask & ~AFL_ASE_MASK) != 0)
14074     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14075 }
14076
14077 static void
14078 print_mips_isa_ext (unsigned int isa_ext)
14079 {
14080   switch (isa_ext)
14081     {
14082     case 0:
14083       fputs (_("None"), stdout);
14084       break;
14085     case AFL_EXT_XLR:
14086       fputs ("RMI XLR", stdout);
14087       break;
14088     case AFL_EXT_OCTEON3:
14089       fputs ("Cavium Networks Octeon3", stdout);
14090       break;
14091     case AFL_EXT_OCTEON2:
14092       fputs ("Cavium Networks Octeon2", stdout);
14093       break;
14094     case AFL_EXT_OCTEONP:
14095       fputs ("Cavium Networks OcteonP", stdout);
14096       break;
14097     case AFL_EXT_LOONGSON_3A:
14098       fputs ("Loongson 3A", stdout);
14099       break;
14100     case AFL_EXT_OCTEON:
14101       fputs ("Cavium Networks Octeon", stdout);
14102       break;
14103     case AFL_EXT_5900:
14104       fputs ("Toshiba R5900", stdout);
14105       break;
14106     case AFL_EXT_4650:
14107       fputs ("MIPS R4650", stdout);
14108       break;
14109     case AFL_EXT_4010:
14110       fputs ("LSI R4010", stdout);
14111       break;
14112     case AFL_EXT_4100:
14113       fputs ("NEC VR4100", stdout);
14114       break;
14115     case AFL_EXT_3900:
14116       fputs ("Toshiba R3900", stdout);
14117       break;
14118     case AFL_EXT_10000:
14119       fputs ("MIPS R10000", stdout);
14120       break;
14121     case AFL_EXT_SB1:
14122       fputs ("Broadcom SB-1", stdout);
14123       break;
14124     case AFL_EXT_4111:
14125       fputs ("NEC VR4111/VR4181", stdout);
14126       break;
14127     case AFL_EXT_4120:
14128       fputs ("NEC VR4120", stdout);
14129       break;
14130     case AFL_EXT_5400:
14131       fputs ("NEC VR5400", stdout);
14132       break;
14133     case AFL_EXT_5500:
14134       fputs ("NEC VR5500", stdout);
14135       break;
14136     case AFL_EXT_LOONGSON_2E:
14137       fputs ("ST Microelectronics Loongson 2E", stdout);
14138       break;
14139     case AFL_EXT_LOONGSON_2F:
14140       fputs ("ST Microelectronics Loongson 2F", stdout);
14141       break;
14142     default:
14143       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14144     }
14145 }
14146
14147 static int
14148 get_mips_reg_size (int reg_size)
14149 {
14150   return (reg_size == AFL_REG_NONE) ? 0
14151          : (reg_size == AFL_REG_32) ? 32
14152          : (reg_size == AFL_REG_64) ? 64
14153          : (reg_size == AFL_REG_128) ? 128
14154          : -1;
14155 }
14156
14157 static int
14158 process_mips_specific (FILE * file)
14159 {
14160   Elf_Internal_Dyn * entry;
14161   Elf_Internal_Shdr *sect = NULL;
14162   size_t liblist_offset = 0;
14163   size_t liblistno = 0;
14164   size_t conflictsno = 0;
14165   size_t options_offset = 0;
14166   size_t conflicts_offset = 0;
14167   size_t pltrelsz = 0;
14168   size_t pltrel = 0;
14169   bfd_vma pltgot = 0;
14170   bfd_vma mips_pltgot = 0;
14171   bfd_vma jmprel = 0;
14172   bfd_vma local_gotno = 0;
14173   bfd_vma gotsym = 0;
14174   bfd_vma symtabno = 0;
14175
14176   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14177                       display_mips_gnu_attribute);
14178
14179   sect = find_section (".MIPS.abiflags");
14180
14181   if (sect != NULL)
14182     {
14183       Elf_External_ABIFlags_v0 *abiflags_ext;
14184       Elf_Internal_ABIFlags_v0 abiflags_in;
14185
14186       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14187         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14188       else
14189         {
14190           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14191                                    sect->sh_size, _("MIPS ABI Flags section"));
14192           if (abiflags_ext)
14193             {
14194               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14195               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14196               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14197               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14198               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14199               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14200               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14201               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14202               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14203               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14204               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14205
14206               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14207               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14208               if (abiflags_in.isa_rev > 1)
14209                 printf ("r%d", abiflags_in.isa_rev);
14210               printf ("\nGPR size: %d",
14211                       get_mips_reg_size (abiflags_in.gpr_size));
14212               printf ("\nCPR1 size: %d",
14213                       get_mips_reg_size (abiflags_in.cpr1_size));
14214               printf ("\nCPR2 size: %d",
14215                       get_mips_reg_size (abiflags_in.cpr2_size));
14216               fputs ("\nFP ABI: ", stdout);
14217               print_mips_fp_abi_value (abiflags_in.fp_abi);
14218               fputs ("ISA Extension: ", stdout);
14219               print_mips_isa_ext (abiflags_in.isa_ext);
14220               fputs ("\nASEs:", stdout);
14221               print_mips_ases (abiflags_in.ases);
14222               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14223               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14224               fputc ('\n', stdout);
14225               free (abiflags_ext);
14226             }
14227         }
14228     }
14229
14230   /* We have a lot of special sections.  Thanks SGI!  */
14231   if (dynamic_section == NULL)
14232     /* No information available.  */
14233     return 0;
14234
14235   for (entry = dynamic_section;
14236        /* PR 17531 file: 012-50589-0.004.  */
14237        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14238        ++entry)
14239     switch (entry->d_tag)
14240       {
14241       case DT_MIPS_LIBLIST:
14242         liblist_offset
14243           = offset_from_vma (file, entry->d_un.d_val,
14244                              liblistno * sizeof (Elf32_External_Lib));
14245         break;
14246       case DT_MIPS_LIBLISTNO:
14247         liblistno = entry->d_un.d_val;
14248         break;
14249       case DT_MIPS_OPTIONS:
14250         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14251         break;
14252       case DT_MIPS_CONFLICT:
14253         conflicts_offset
14254           = offset_from_vma (file, entry->d_un.d_val,
14255                              conflictsno * sizeof (Elf32_External_Conflict));
14256         break;
14257       case DT_MIPS_CONFLICTNO:
14258         conflictsno = entry->d_un.d_val;
14259         break;
14260       case DT_PLTGOT:
14261         pltgot = entry->d_un.d_ptr;
14262         break;
14263       case DT_MIPS_LOCAL_GOTNO:
14264         local_gotno = entry->d_un.d_val;
14265         break;
14266       case DT_MIPS_GOTSYM:
14267         gotsym = entry->d_un.d_val;
14268         break;
14269       case DT_MIPS_SYMTABNO:
14270         symtabno = entry->d_un.d_val;
14271         break;
14272       case DT_MIPS_PLTGOT:
14273         mips_pltgot = entry->d_un.d_ptr;
14274         break;
14275       case DT_PLTREL:
14276         pltrel = entry->d_un.d_val;
14277         break;
14278       case DT_PLTRELSZ:
14279         pltrelsz = entry->d_un.d_val;
14280         break;
14281       case DT_JMPREL:
14282         jmprel = entry->d_un.d_ptr;
14283         break;
14284       default:
14285         break;
14286       }
14287
14288   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14289     {
14290       Elf32_External_Lib * elib;
14291       size_t cnt;
14292
14293       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14294                                               liblistno,
14295                                               sizeof (Elf32_External_Lib),
14296                                               _("liblist section data"));
14297       if (elib)
14298         {
14299           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14300                   (unsigned long) liblistno);
14301           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14302                  stdout);
14303
14304           for (cnt = 0; cnt < liblistno; ++cnt)
14305             {
14306               Elf32_Lib liblist;
14307               time_t atime;
14308               char timebuf[20];
14309               struct tm * tmp;
14310
14311               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14312               atime = BYTE_GET (elib[cnt].l_time_stamp);
14313               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14314               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14315               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14316
14317               tmp = gmtime (&atime);
14318               snprintf (timebuf, sizeof (timebuf),
14319                         "%04u-%02u-%02uT%02u:%02u:%02u",
14320                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14321                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14322
14323               printf ("%3lu: ", (unsigned long) cnt);
14324               if (VALID_DYNAMIC_NAME (liblist.l_name))
14325                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14326               else
14327                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14328               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14329                       liblist.l_version);
14330
14331               if (liblist.l_flags == 0)
14332                 puts (_(" NONE"));
14333               else
14334                 {
14335                   static const struct
14336                   {
14337                     const char * name;
14338                     int bit;
14339                   }
14340                   l_flags_vals[] =
14341                   {
14342                     { " EXACT_MATCH", LL_EXACT_MATCH },
14343                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14344                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14345                     { " EXPORTS", LL_EXPORTS },
14346                     { " DELAY_LOAD", LL_DELAY_LOAD },
14347                     { " DELTA", LL_DELTA }
14348                   };
14349                   int flags = liblist.l_flags;
14350                   size_t fcnt;
14351
14352                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14353                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14354                       {
14355                         fputs (l_flags_vals[fcnt].name, stdout);
14356                         flags ^= l_flags_vals[fcnt].bit;
14357                       }
14358                   if (flags != 0)
14359                     printf (" %#x", (unsigned int) flags);
14360
14361                   puts ("");
14362                 }
14363             }
14364
14365           free (elib);
14366         }
14367     }
14368
14369   if (options_offset != 0)
14370     {
14371       Elf_External_Options * eopt;
14372       Elf_Internal_Options * iopt;
14373       Elf_Internal_Options * option;
14374       size_t offset;
14375       int cnt;
14376       sect = section_headers;
14377
14378       /* Find the section header so that we get the size.  */
14379       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14380       /* PR 17533 file: 012-277276-0.004.  */
14381       if (sect == NULL)
14382         {
14383           error (_("No MIPS_OPTIONS header found\n"));
14384           return 0;
14385         }
14386
14387       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14388                                                 sect->sh_size, _("options"));
14389       if (eopt)
14390         {
14391           iopt = (Elf_Internal_Options *)
14392               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14393           if (iopt == NULL)
14394             {
14395               error (_("Out of memory allocatinf space for MIPS options\n"));
14396               return 0;
14397             }
14398
14399           offset = cnt = 0;
14400           option = iopt;
14401
14402           while (offset <= sect->sh_size - sizeof (* eopt))
14403             {
14404               Elf_External_Options * eoption;
14405
14406               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14407
14408               option->kind = BYTE_GET (eoption->kind);
14409               option->size = BYTE_GET (eoption->size);
14410               option->section = BYTE_GET (eoption->section);
14411               option->info = BYTE_GET (eoption->info);
14412
14413               /* PR 17531: file: ffa0fa3b.  */
14414               if (option->size < sizeof (* eopt)
14415                   || offset + option->size > sect->sh_size)
14416                 {
14417                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14418                   return 0;
14419                 }
14420               offset += option->size;
14421
14422               ++option;
14423               ++cnt;
14424             }
14425
14426           printf (_("\nSection '%s' contains %d entries:\n"),
14427                   printable_section_name (sect), cnt);
14428
14429           option = iopt;
14430           offset = 0;
14431
14432           while (cnt-- > 0)
14433             {
14434               size_t len;
14435
14436               switch (option->kind)
14437                 {
14438                 case ODK_NULL:
14439                   /* This shouldn't happen.  */
14440                   printf (" NULL       %d %lx", option->section, option->info);
14441                   break;
14442                 case ODK_REGINFO:
14443                   printf (" REGINFO    ");
14444                   if (elf_header.e_machine == EM_MIPS)
14445                     {
14446                       /* 32bit form.  */
14447                       Elf32_External_RegInfo * ereg;
14448                       Elf32_RegInfo reginfo;
14449
14450                       ereg = (Elf32_External_RegInfo *) (option + 1);
14451                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14452                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14453                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14454                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14455                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14456                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14457
14458                       printf ("GPR %08lx  GP 0x%lx\n",
14459                               reginfo.ri_gprmask,
14460                               (unsigned long) reginfo.ri_gp_value);
14461                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14462                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14463                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14464                     }
14465                   else
14466                     {
14467                       /* 64 bit form.  */
14468                       Elf64_External_RegInfo * ereg;
14469                       Elf64_Internal_RegInfo reginfo;
14470
14471                       ereg = (Elf64_External_RegInfo *) (option + 1);
14472                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14473                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14474                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14475                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14476                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14477                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14478
14479                       printf ("GPR %08lx  GP 0x",
14480                               reginfo.ri_gprmask);
14481                       printf_vma (reginfo.ri_gp_value);
14482                       printf ("\n");
14483
14484                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14485                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14486                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14487                     }
14488                   ++option;
14489                   continue;
14490                 case ODK_EXCEPTIONS:
14491                   fputs (" EXCEPTIONS fpe_min(", stdout);
14492                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14493                   fputs (") fpe_max(", stdout);
14494                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14495                   fputs (")", stdout);
14496
14497                   if (option->info & OEX_PAGE0)
14498                     fputs (" PAGE0", stdout);
14499                   if (option->info & OEX_SMM)
14500                     fputs (" SMM", stdout);
14501                   if (option->info & OEX_FPDBUG)
14502                     fputs (" FPDBUG", stdout);
14503                   if (option->info & OEX_DISMISS)
14504                     fputs (" DISMISS", stdout);
14505                   break;
14506                 case ODK_PAD:
14507                   fputs (" PAD       ", stdout);
14508                   if (option->info & OPAD_PREFIX)
14509                     fputs (" PREFIX", stdout);
14510                   if (option->info & OPAD_POSTFIX)
14511                     fputs (" POSTFIX", stdout);
14512                   if (option->info & OPAD_SYMBOL)
14513                     fputs (" SYMBOL", stdout);
14514                   break;
14515                 case ODK_HWPATCH:
14516                   fputs (" HWPATCH   ", stdout);
14517                   if (option->info & OHW_R4KEOP)
14518                     fputs (" R4KEOP", stdout);
14519                   if (option->info & OHW_R8KPFETCH)
14520                     fputs (" R8KPFETCH", stdout);
14521                   if (option->info & OHW_R5KEOP)
14522                     fputs (" R5KEOP", stdout);
14523                   if (option->info & OHW_R5KCVTL)
14524                     fputs (" R5KCVTL", stdout);
14525                   break;
14526                 case ODK_FILL:
14527                   fputs (" FILL       ", stdout);
14528                   /* XXX Print content of info word?  */
14529                   break;
14530                 case ODK_TAGS:
14531                   fputs (" TAGS       ", stdout);
14532                   /* XXX Print content of info word?  */
14533                   break;
14534                 case ODK_HWAND:
14535                   fputs (" HWAND     ", stdout);
14536                   if (option->info & OHWA0_R4KEOP_CHECKED)
14537                     fputs (" R4KEOP_CHECKED", stdout);
14538                   if (option->info & OHWA0_R4KEOP_CLEAN)
14539                     fputs (" R4KEOP_CLEAN", stdout);
14540                   break;
14541                 case ODK_HWOR:
14542                   fputs (" HWOR      ", stdout);
14543                   if (option->info & OHWA0_R4KEOP_CHECKED)
14544                     fputs (" R4KEOP_CHECKED", stdout);
14545                   if (option->info & OHWA0_R4KEOP_CLEAN)
14546                     fputs (" R4KEOP_CLEAN", stdout);
14547                   break;
14548                 case ODK_GP_GROUP:
14549                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14550                           option->info & OGP_GROUP,
14551                           (option->info & OGP_SELF) >> 16);
14552                   break;
14553                 case ODK_IDENT:
14554                   printf (" IDENT     %#06lx  self-contained %#06lx",
14555                           option->info & OGP_GROUP,
14556                           (option->info & OGP_SELF) >> 16);
14557                   break;
14558                 default:
14559                   /* This shouldn't happen.  */
14560                   printf (" %3d ???     %d %lx",
14561                           option->kind, option->section, option->info);
14562                   break;
14563                 }
14564
14565               len = sizeof (* eopt);
14566               while (len < option->size)
14567                 {
14568                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
14569
14570                   if (ISPRINT (datum))
14571                     printf ("%c", datum);
14572                   else
14573                     printf ("\\%03o", datum);
14574                   len ++;
14575                 }
14576               fputs ("\n", stdout);
14577
14578               offset += option->size;
14579               ++option;
14580             }
14581
14582           free (eopt);
14583         }
14584     }
14585
14586   if (conflicts_offset != 0 && conflictsno != 0)
14587     {
14588       Elf32_Conflict * iconf;
14589       size_t cnt;
14590
14591       if (dynamic_symbols == NULL)
14592         {
14593           error (_("conflict list found without a dynamic symbol table\n"));
14594           return 0;
14595         }
14596
14597       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14598       if (iconf == NULL)
14599         {
14600           error (_("Out of memory allocating space for dynamic conflicts\n"));
14601           return 0;
14602         }
14603
14604       if (is_32bit_elf)
14605         {
14606           Elf32_External_Conflict * econf32;
14607
14608           econf32 = (Elf32_External_Conflict *)
14609               get_data (NULL, file, conflicts_offset, conflictsno,
14610                         sizeof (* econf32), _("conflict"));
14611           if (!econf32)
14612             return 0;
14613
14614           for (cnt = 0; cnt < conflictsno; ++cnt)
14615             iconf[cnt] = BYTE_GET (econf32[cnt]);
14616
14617           free (econf32);
14618         }
14619       else
14620         {
14621           Elf64_External_Conflict * econf64;
14622
14623           econf64 = (Elf64_External_Conflict *)
14624               get_data (NULL, file, conflicts_offset, conflictsno,
14625                         sizeof (* econf64), _("conflict"));
14626           if (!econf64)
14627             return 0;
14628
14629           for (cnt = 0; cnt < conflictsno; ++cnt)
14630             iconf[cnt] = BYTE_GET (econf64[cnt]);
14631
14632           free (econf64);
14633         }
14634
14635       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14636               (unsigned long) conflictsno);
14637       puts (_("  Num:    Index       Value  Name"));
14638
14639       for (cnt = 0; cnt < conflictsno; ++cnt)
14640         {
14641           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14642
14643           if (iconf[cnt] >= num_dynamic_syms)
14644             printf (_("<corrupt symbol index>"));
14645           else
14646             {
14647               Elf_Internal_Sym * psym;
14648
14649               psym = & dynamic_symbols[iconf[cnt]];
14650               print_vma (psym->st_value, FULL_HEX);
14651               putchar (' ');
14652               if (VALID_DYNAMIC_NAME (psym->st_name))
14653                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14654               else
14655                 printf (_("<corrupt: %14ld>"), psym->st_name);
14656             }
14657           putchar ('\n');
14658         }
14659
14660       free (iconf);
14661     }
14662
14663   if (pltgot != 0 && local_gotno != 0)
14664     {
14665       bfd_vma ent, local_end, global_end;
14666       size_t i, offset;
14667       unsigned char * data;
14668       unsigned char * data_end;
14669       int addr_size;
14670
14671       ent = pltgot;
14672       addr_size = (is_32bit_elf ? 4 : 8);
14673       local_end = pltgot + local_gotno * addr_size;
14674
14675       /* PR binutils/17533 file: 012-111227-0.004  */
14676       if (symtabno < gotsym)
14677         {
14678           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14679                  (unsigned long) gotsym, (unsigned long) symtabno);
14680           return 0;
14681         }
14682
14683       global_end = local_end + (symtabno - gotsym) * addr_size;
14684       /* PR 17531: file: 54c91a34.  */
14685       if (global_end < local_end)
14686         {
14687           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14688           return 0;
14689         }
14690
14691       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14692       data = (unsigned char *) get_data (NULL, file, offset,
14693                                          global_end - pltgot, 1,
14694                                          _("Global Offset Table data"));
14695       if (data == NULL)
14696         return 0;
14697       data_end = data + (global_end - pltgot);
14698
14699       printf (_("\nPrimary GOT:\n"));
14700       printf (_(" Canonical gp value: "));
14701       print_vma (pltgot + 0x7ff0, LONG_HEX);
14702       printf ("\n\n");
14703
14704       printf (_(" Reserved entries:\n"));
14705       printf (_("  %*s %10s %*s Purpose\n"),
14706               addr_size * 2, _("Address"), _("Access"),
14707               addr_size * 2, _("Initial"));
14708       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14709       printf (_(" Lazy resolver\n"));
14710       if (ent == (bfd_vma) -1)
14711         goto got_print_fail;
14712       if (data
14713           && (byte_get (data + ent - pltgot, addr_size)
14714               >> (addr_size * 8 - 1)) != 0)
14715         {
14716           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14717           printf (_(" Module pointer (GNU extension)\n"));
14718           if (ent == (bfd_vma) -1)
14719             goto got_print_fail;
14720         }
14721       printf ("\n");
14722
14723       if (ent < local_end)
14724         {
14725           printf (_(" Local entries:\n"));
14726           printf ("  %*s %10s %*s\n",
14727                   addr_size * 2, _("Address"), _("Access"),
14728                   addr_size * 2, _("Initial"));
14729           while (ent < local_end)
14730             {
14731               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14732               printf ("\n");
14733               if (ent == (bfd_vma) -1)
14734                 goto got_print_fail;
14735             }
14736           printf ("\n");
14737         }
14738
14739       if (gotsym < symtabno)
14740         {
14741           int sym_width;
14742
14743           printf (_(" Global entries:\n"));
14744           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14745                   addr_size * 2, _("Address"),
14746                   _("Access"),
14747                   addr_size * 2, _("Initial"),
14748                   addr_size * 2, _("Sym.Val."),
14749                   _("Type"),
14750                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14751                   _("Ndx"), _("Name"));
14752
14753           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14754
14755           for (i = gotsym; i < symtabno; i++)
14756             {
14757               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14758               printf (" ");
14759
14760               if (dynamic_symbols == NULL)
14761                 printf (_("<no dynamic symbols>"));
14762               else if (i < num_dynamic_syms)
14763                 {
14764                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14765
14766                   print_vma (psym->st_value, LONG_HEX);
14767                   printf (" %-7s %3s ",
14768                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14769                           get_symbol_index_type (psym->st_shndx));
14770
14771                   if (VALID_DYNAMIC_NAME (psym->st_name))
14772                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14773                   else
14774                     printf (_("<corrupt: %14ld>"), psym->st_name);
14775                 }
14776               else
14777                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14778                         (unsigned long) i);
14779
14780               printf ("\n");
14781               if (ent == (bfd_vma) -1)
14782                 break;
14783             }
14784           printf ("\n");
14785         }
14786
14787     got_print_fail:
14788       if (data)
14789         free (data);
14790     }
14791
14792   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14793     {
14794       bfd_vma ent, end;
14795       size_t offset, rel_offset;
14796       unsigned long count, i;
14797       unsigned char * data;
14798       int addr_size, sym_width;
14799       Elf_Internal_Rela * rels;
14800
14801       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14802       if (pltrel == DT_RELA)
14803         {
14804           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14805             return 0;
14806         }
14807       else
14808         {
14809           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14810             return 0;
14811         }
14812
14813       ent = mips_pltgot;
14814       addr_size = (is_32bit_elf ? 4 : 8);
14815       end = mips_pltgot + (2 + count) * addr_size;
14816
14817       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14818       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14819                                          1, _("Procedure Linkage Table data"));
14820       if (data == NULL)
14821         return 0;
14822
14823       printf ("\nPLT GOT:\n\n");
14824       printf (_(" Reserved entries:\n"));
14825       printf (_("  %*s %*s Purpose\n"),
14826               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14827       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14828       printf (_(" PLT lazy resolver\n"));
14829       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14830       printf (_(" Module pointer\n"));
14831       printf ("\n");
14832
14833       printf (_(" Entries:\n"));
14834       printf ("  %*s %*s %*s %-7s %3s %s\n",
14835               addr_size * 2, _("Address"),
14836               addr_size * 2, _("Initial"),
14837               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14838       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14839       for (i = 0; i < count; i++)
14840         {
14841           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14842
14843           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14844           printf (" ");
14845
14846           if (idx >= num_dynamic_syms)
14847             printf (_("<corrupt symbol index: %lu>"), idx);
14848           else
14849             {
14850               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14851
14852               print_vma (psym->st_value, LONG_HEX);
14853               printf (" %-7s %3s ",
14854                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14855                       get_symbol_index_type (psym->st_shndx));
14856               if (VALID_DYNAMIC_NAME (psym->st_name))
14857                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14858               else
14859                 printf (_("<corrupt: %14ld>"), psym->st_name);
14860             }
14861           printf ("\n");
14862         }
14863       printf ("\n");
14864
14865       if (data)
14866         free (data);
14867       free (rels);
14868     }
14869
14870   return 1;
14871 }
14872
14873 static int
14874 process_nds32_specific (FILE * file)
14875 {
14876   Elf_Internal_Shdr *sect = NULL;
14877
14878   sect = find_section (".nds32_e_flags");
14879   if (sect != NULL)
14880     {
14881       unsigned int *flag;
14882
14883       printf ("\nNDS32 elf flags section:\n");
14884       flag = get_data (NULL, file, sect->sh_offset, 1,
14885                        sect->sh_size, _("NDS32 elf flags section"));
14886
14887       switch ((*flag) & 0x3)
14888         {
14889         case 0:
14890           printf ("(VEC_SIZE):\tNo entry.\n");
14891           break;
14892         case 1:
14893           printf ("(VEC_SIZE):\t4 bytes\n");
14894           break;
14895         case 2:
14896           printf ("(VEC_SIZE):\t16 bytes\n");
14897           break;
14898         case 3:
14899           printf ("(VEC_SIZE):\treserved\n");
14900           break;
14901         }
14902     }
14903
14904   return TRUE;
14905 }
14906
14907 static int
14908 process_gnu_liblist (FILE * file)
14909 {
14910   Elf_Internal_Shdr * section;
14911   Elf_Internal_Shdr * string_sec;
14912   Elf32_External_Lib * elib;
14913   char * strtab;
14914   size_t strtab_size;
14915   size_t cnt;
14916   unsigned i;
14917
14918   if (! do_arch)
14919     return 0;
14920
14921   for (i = 0, section = section_headers;
14922        i < elf_header.e_shnum;
14923        i++, section++)
14924     {
14925       switch (section->sh_type)
14926         {
14927         case SHT_GNU_LIBLIST:
14928           if (section->sh_link >= elf_header.e_shnum)
14929             break;
14930
14931           elib = (Elf32_External_Lib *)
14932               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14933                         _("liblist section data"));
14934
14935           if (elib == NULL)
14936             break;
14937           string_sec = section_headers + section->sh_link;
14938
14939           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14940                                       string_sec->sh_size,
14941                                       _("liblist string table"));
14942           if (strtab == NULL
14943               || section->sh_entsize != sizeof (Elf32_External_Lib))
14944             {
14945               free (elib);
14946               free (strtab);
14947               break;
14948             }
14949           strtab_size = string_sec->sh_size;
14950
14951           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14952                   printable_section_name (section),
14953                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14954
14955           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14956
14957           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14958                ++cnt)
14959             {
14960               Elf32_Lib liblist;
14961               time_t atime;
14962               char timebuf[20];
14963               struct tm * tmp;
14964
14965               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14966               atime = BYTE_GET (elib[cnt].l_time_stamp);
14967               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14968               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14969               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14970
14971               tmp = gmtime (&atime);
14972               snprintf (timebuf, sizeof (timebuf),
14973                         "%04u-%02u-%02uT%02u:%02u:%02u",
14974                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14975                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14976
14977               printf ("%3lu: ", (unsigned long) cnt);
14978               if (do_wide)
14979                 printf ("%-20s", liblist.l_name < strtab_size
14980                         ? strtab + liblist.l_name : _("<corrupt>"));
14981               else
14982                 printf ("%-20.20s", liblist.l_name < strtab_size
14983                         ? strtab + liblist.l_name : _("<corrupt>"));
14984               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14985                       liblist.l_version, liblist.l_flags);
14986             }
14987
14988           free (elib);
14989           free (strtab);
14990         }
14991     }
14992
14993   return 1;
14994 }
14995
14996 static const char *
14997 get_note_type (unsigned e_type)
14998 {
14999   static char buff[64];
15000
15001   if (elf_header.e_type == ET_CORE)
15002     switch (e_type)
15003       {
15004       case NT_AUXV:
15005         return _("NT_AUXV (auxiliary vector)");
15006       case NT_PRSTATUS:
15007         return _("NT_PRSTATUS (prstatus structure)");
15008       case NT_FPREGSET:
15009         return _("NT_FPREGSET (floating point registers)");
15010       case NT_PRPSINFO:
15011         return _("NT_PRPSINFO (prpsinfo structure)");
15012       case NT_TASKSTRUCT:
15013         return _("NT_TASKSTRUCT (task structure)");
15014       case NT_PRXFPREG:
15015         return _("NT_PRXFPREG (user_xfpregs structure)");
15016       case NT_PPC_VMX:
15017         return _("NT_PPC_VMX (ppc Altivec registers)");
15018       case NT_PPC_VSX:
15019         return _("NT_PPC_VSX (ppc VSX registers)");
15020       case NT_386_TLS:
15021         return _("NT_386_TLS (x86 TLS information)");
15022       case NT_386_IOPERM:
15023         return _("NT_386_IOPERM (x86 I/O permissions)");
15024       case NT_X86_XSTATE:
15025         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15026       case NT_S390_HIGH_GPRS:
15027         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15028       case NT_S390_TIMER:
15029         return _("NT_S390_TIMER (s390 timer register)");
15030       case NT_S390_TODCMP:
15031         return _("NT_S390_TODCMP (s390 TOD comparator register)");
15032       case NT_S390_TODPREG:
15033         return _("NT_S390_TODPREG (s390 TOD programmable register)");
15034       case NT_S390_CTRS:
15035         return _("NT_S390_CTRS (s390 control registers)");
15036       case NT_S390_PREFIX:
15037         return _("NT_S390_PREFIX (s390 prefix register)");
15038       case NT_S390_LAST_BREAK:
15039         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15040       case NT_S390_SYSTEM_CALL:
15041         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15042       case NT_S390_TDB:
15043         return _("NT_S390_TDB (s390 transaction diagnostic block)");
15044       case NT_S390_VXRS_LOW:
15045         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15046       case NT_S390_VXRS_HIGH:
15047         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15048       case NT_ARM_VFP:
15049         return _("NT_ARM_VFP (arm VFP registers)");
15050       case NT_ARM_TLS:
15051         return _("NT_ARM_TLS (AArch TLS registers)");
15052       case NT_ARM_HW_BREAK:
15053         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15054       case NT_ARM_HW_WATCH:
15055         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15056       case NT_PSTATUS:
15057         return _("NT_PSTATUS (pstatus structure)");
15058       case NT_FPREGS:
15059         return _("NT_FPREGS (floating point registers)");
15060       case NT_PSINFO:
15061         return _("NT_PSINFO (psinfo structure)");
15062       case NT_LWPSTATUS:
15063         return _("NT_LWPSTATUS (lwpstatus_t structure)");
15064       case NT_LWPSINFO:
15065         return _("NT_LWPSINFO (lwpsinfo_t structure)");
15066       case NT_WIN32PSTATUS:
15067         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15068       case NT_SIGINFO:
15069         return _("NT_SIGINFO (siginfo_t data)");
15070       case NT_FILE:
15071         return _("NT_FILE (mapped files)");
15072       default:
15073         break;
15074       }
15075   else
15076     switch (e_type)
15077       {
15078       case NT_VERSION:
15079         return _("NT_VERSION (version)");
15080       case NT_ARCH:
15081         return _("NT_ARCH (architecture)");
15082       default:
15083         break;
15084       }
15085
15086   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15087   return buff;
15088 }
15089
15090 static int
15091 print_core_note (Elf_Internal_Note *pnote)
15092 {
15093   unsigned int addr_size = is_32bit_elf ? 4 : 8;
15094   bfd_vma count, page_size;
15095   unsigned char *descdata, *filenames, *descend;
15096
15097   if (pnote->type != NT_FILE)
15098     return 1;
15099
15100 #ifndef BFD64
15101   if (!is_32bit_elf)
15102     {
15103       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
15104       /* Still "successful".  */
15105       return 1;
15106     }
15107 #endif
15108
15109   if (pnote->descsz < 2 * addr_size)
15110     {
15111       printf (_("    Malformed note - too short for header\n"));
15112       return 0;
15113     }
15114
15115   descdata = (unsigned char *) pnote->descdata;
15116   descend = descdata + pnote->descsz;
15117
15118   if (descdata[pnote->descsz - 1] != '\0')
15119     {
15120       printf (_("    Malformed note - does not end with \\0\n"));
15121       return 0;
15122     }
15123
15124   count = byte_get (descdata, addr_size);
15125   descdata += addr_size;
15126
15127   page_size = byte_get (descdata, addr_size);
15128   descdata += addr_size;
15129
15130   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15131     {
15132       printf (_("    Malformed note - too short for supplied file count\n"));
15133       return 0;
15134     }
15135
15136   printf (_("    Page size: "));
15137   print_vma (page_size, DEC);
15138   printf ("\n");
15139
15140   printf (_("    %*s%*s%*s\n"),
15141           (int) (2 + 2 * addr_size), _("Start"),
15142           (int) (4 + 2 * addr_size), _("End"),
15143           (int) (4 + 2 * addr_size), _("Page Offset"));
15144   filenames = descdata + count * 3 * addr_size;
15145   while (count-- > 0)
15146     {
15147       bfd_vma start, end, file_ofs;
15148
15149       if (filenames == descend)
15150         {
15151           printf (_("    Malformed note - filenames end too early\n"));
15152           return 0;
15153         }
15154
15155       start = byte_get (descdata, addr_size);
15156       descdata += addr_size;
15157       end = byte_get (descdata, addr_size);
15158       descdata += addr_size;
15159       file_ofs = byte_get (descdata, addr_size);
15160       descdata += addr_size;
15161
15162       printf ("    ");
15163       print_vma (start, FULL_HEX);
15164       printf ("  ");
15165       print_vma (end, FULL_HEX);
15166       printf ("  ");
15167       print_vma (file_ofs, FULL_HEX);
15168       printf ("\n        %s\n", filenames);
15169
15170       filenames += 1 + strlen ((char *) filenames);
15171     }
15172
15173   return 1;
15174 }
15175
15176 static const char *
15177 get_gnu_elf_note_type (unsigned e_type)
15178 {
15179   static char buff[64];
15180
15181   switch (e_type)
15182     {
15183     case NT_GNU_ABI_TAG:
15184       return _("NT_GNU_ABI_TAG (ABI version tag)");
15185     case NT_GNU_HWCAP:
15186       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15187     case NT_GNU_BUILD_ID:
15188       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15189     case NT_GNU_GOLD_VERSION:
15190       return _("NT_GNU_GOLD_VERSION (gold version)");
15191     default:
15192       break;
15193     }
15194
15195   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15196   return buff;
15197 }
15198
15199 static int
15200 print_gnu_note (Elf_Internal_Note *pnote)
15201 {
15202   switch (pnote->type)
15203     {
15204     case NT_GNU_BUILD_ID:
15205       {
15206         unsigned long i;
15207
15208         printf (_("    Build ID: "));
15209         for (i = 0; i < pnote->descsz; ++i)
15210           printf ("%02x", pnote->descdata[i] & 0xff);
15211         printf ("\n");
15212       }
15213       break;
15214
15215     case NT_GNU_ABI_TAG:
15216       {
15217         unsigned long os, major, minor, subminor;
15218         const char *osname;
15219
15220         /* PR 17531: file: 030-599401-0.004.  */
15221         if (pnote->descsz < 16)
15222           {
15223             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15224             break;
15225           }
15226
15227         os = byte_get ((unsigned char *) pnote->descdata, 4);
15228         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15229         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15230         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15231
15232         switch (os)
15233           {
15234           case GNU_ABI_TAG_LINUX:
15235             osname = "Linux";
15236             break;
15237           case GNU_ABI_TAG_HURD:
15238             osname = "Hurd";
15239             break;
15240           case GNU_ABI_TAG_SOLARIS:
15241             osname = "Solaris";
15242             break;
15243           case GNU_ABI_TAG_FREEBSD:
15244             osname = "FreeBSD";
15245             break;
15246           case GNU_ABI_TAG_NETBSD:
15247             osname = "NetBSD";
15248             break;
15249           case GNU_ABI_TAG_SYLLABLE:
15250             osname = "Syllable";
15251             break;
15252           case GNU_ABI_TAG_NACL:
15253             osname = "NaCl";
15254             break;
15255           default:
15256             osname = "Unknown";
15257             break;
15258           }
15259
15260         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15261                 major, minor, subminor);
15262       }
15263       break;
15264
15265     case NT_GNU_GOLD_VERSION:
15266       {
15267         unsigned long i;
15268
15269         printf (_("    Version: "));
15270         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15271           printf ("%c", pnote->descdata[i]);
15272         printf ("\n");
15273       }
15274       break;
15275     }
15276
15277   return 1;
15278 }
15279
15280 static const char *
15281 get_v850_elf_note_type (enum v850_notes n_type)
15282 {
15283   static char buff[64];
15284
15285   switch (n_type)
15286     {
15287     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15288     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15289     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15290     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15291     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15292     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15293     default:
15294       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15295       return buff;
15296     }
15297 }
15298
15299 static int
15300 print_v850_note (Elf_Internal_Note * pnote)
15301 {
15302   unsigned int val;
15303
15304   if (pnote->descsz != 4)
15305     return 0;
15306   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15307
15308   if (val == 0)
15309     {
15310       printf (_("not set\n"));
15311       return 1;
15312     }
15313
15314   switch (pnote->type)
15315     {
15316     case V850_NOTE_ALIGNMENT:
15317       switch (val)
15318         {
15319         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15320         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15321         }
15322       break;
15323
15324     case V850_NOTE_DATA_SIZE:
15325       switch (val)
15326         {
15327         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15328         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15329         }
15330       break;
15331
15332     case V850_NOTE_FPU_INFO:
15333       switch (val)
15334         {
15335         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15336         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15337         }
15338       break;
15339
15340     case V850_NOTE_MMU_INFO:
15341     case V850_NOTE_CACHE_INFO:
15342     case V850_NOTE_SIMD_INFO:
15343       if (val == EF_RH850_SIMD)
15344         {
15345           printf (_("yes\n"));
15346           return 1;
15347         }
15348       break;
15349
15350     default:
15351       /* An 'unknown note type' message will already have been displayed.  */
15352       break;
15353     }
15354
15355   printf (_("unknown value: %x\n"), val);
15356   return 0;
15357 }
15358
15359 static int
15360 process_netbsd_elf_note (Elf_Internal_Note * pnote)
15361 {
15362   unsigned int version;
15363
15364   switch (pnote->type)
15365     {
15366     case NT_NETBSD_IDENT:
15367       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15368       if ((version / 10000) % 100)
15369         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15370                 version, version / 100000000, (version / 1000000) % 100,
15371                 (version / 10000) % 100 > 26 ? "Z" : "",
15372                 'A' + (version / 10000) % 26);
15373       else
15374         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15375                 version, version / 100000000, (version / 1000000) % 100,
15376                 (version / 100) % 100);
15377       return 1;
15378
15379     case NT_NETBSD_MARCH:
15380       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15381               pnote->descdata);
15382       return 1;
15383
15384     default:
15385       break;
15386     }
15387
15388   printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15389           pnote->type);
15390   return 1;
15391 }
15392
15393 static const char *
15394 get_netbsd_elfcore_note_type (unsigned e_type)
15395 {
15396   static char buff[64];
15397
15398   if (e_type == NT_NETBSDCORE_PROCINFO)
15399     {
15400       /* NetBSD core "procinfo" structure.  */
15401       return _("NetBSD procinfo structure");
15402     }
15403
15404   /* As of Jan 2002 there are no other machine-independent notes
15405      defined for NetBSD core files.  If the note type is less
15406      than the start of the machine-dependent note types, we don't
15407      understand it.  */
15408
15409   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15410     {
15411       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15412       return buff;
15413     }
15414
15415   switch (elf_header.e_machine)
15416     {
15417     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15418        and PT_GETFPREGS == mach+2.  */
15419
15420     case EM_OLD_ALPHA:
15421     case EM_ALPHA:
15422     case EM_SPARC:
15423     case EM_SPARC32PLUS:
15424     case EM_SPARCV9:
15425       switch (e_type)
15426         {
15427         case NT_NETBSDCORE_FIRSTMACH + 0:
15428           return _("PT_GETREGS (reg structure)");
15429         case NT_NETBSDCORE_FIRSTMACH + 2:
15430           return _("PT_GETFPREGS (fpreg structure)");
15431         default:
15432           break;
15433         }
15434       break;
15435
15436     /* On all other arch's, PT_GETREGS == mach+1 and
15437        PT_GETFPREGS == mach+3.  */
15438     default:
15439       switch (e_type)
15440         {
15441         case NT_NETBSDCORE_FIRSTMACH + 1:
15442           return _("PT_GETREGS (reg structure)");
15443         case NT_NETBSDCORE_FIRSTMACH + 3:
15444           return _("PT_GETFPREGS (fpreg structure)");
15445         default:
15446           break;
15447         }
15448     }
15449
15450   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15451             e_type - NT_NETBSDCORE_FIRSTMACH);
15452   return buff;
15453 }
15454
15455 static const char *
15456 get_stapsdt_note_type (unsigned e_type)
15457 {
15458   static char buff[64];
15459
15460   switch (e_type)
15461     {
15462     case NT_STAPSDT:
15463       return _("NT_STAPSDT (SystemTap probe descriptors)");
15464
15465     default:
15466       break;
15467     }
15468
15469   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15470   return buff;
15471 }
15472
15473 static int
15474 print_stapsdt_note (Elf_Internal_Note *pnote)
15475 {
15476   int addr_size = is_32bit_elf ? 4 : 8;
15477   char *data = pnote->descdata;
15478   char *data_end = pnote->descdata + pnote->descsz;
15479   bfd_vma pc, base_addr, semaphore;
15480   char *provider, *probe, *arg_fmt;
15481
15482   pc = byte_get ((unsigned char *) data, addr_size);
15483   data += addr_size;
15484   base_addr = byte_get ((unsigned char *) data, addr_size);
15485   data += addr_size;
15486   semaphore = byte_get ((unsigned char *) data, addr_size);
15487   data += addr_size;
15488
15489   provider = data;
15490   data += strlen (data) + 1;
15491   probe = data;
15492   data += strlen (data) + 1;
15493   arg_fmt = data;
15494   data += strlen (data) + 1;
15495
15496   printf (_("    Provider: %s\n"), provider);
15497   printf (_("    Name: %s\n"), probe);
15498   printf (_("    Location: "));
15499   print_vma (pc, FULL_HEX);
15500   printf (_(", Base: "));
15501   print_vma (base_addr, FULL_HEX);
15502   printf (_(", Semaphore: "));
15503   print_vma (semaphore, FULL_HEX);
15504   printf ("\n");
15505   printf (_("    Arguments: %s\n"), arg_fmt);
15506
15507   return data == data_end;
15508 }
15509
15510 static const char *
15511 get_ia64_vms_note_type (unsigned e_type)
15512 {
15513   static char buff[64];
15514
15515   switch (e_type)
15516     {
15517     case NT_VMS_MHD:
15518       return _("NT_VMS_MHD (module header)");
15519     case NT_VMS_LNM:
15520       return _("NT_VMS_LNM (language name)");
15521     case NT_VMS_SRC:
15522       return _("NT_VMS_SRC (source files)");
15523     case NT_VMS_TITLE:
15524       return "NT_VMS_TITLE";
15525     case NT_VMS_EIDC:
15526       return _("NT_VMS_EIDC (consistency check)");
15527     case NT_VMS_FPMODE:
15528       return _("NT_VMS_FPMODE (FP mode)");
15529     case NT_VMS_LINKTIME:
15530       return "NT_VMS_LINKTIME";
15531     case NT_VMS_IMGNAM:
15532       return _("NT_VMS_IMGNAM (image name)");
15533     case NT_VMS_IMGID:
15534       return _("NT_VMS_IMGID (image id)");
15535     case NT_VMS_LINKID:
15536       return _("NT_VMS_LINKID (link id)");
15537     case NT_VMS_IMGBID:
15538       return _("NT_VMS_IMGBID (build id)");
15539     case NT_VMS_GSTNAM:
15540       return _("NT_VMS_GSTNAM (sym table name)");
15541     case NT_VMS_ORIG_DYN:
15542       return "NT_VMS_ORIG_DYN";
15543     case NT_VMS_PATCHTIME:
15544       return "NT_VMS_PATCHTIME";
15545     default:
15546       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15547       return buff;
15548     }
15549 }
15550
15551 static int
15552 print_ia64_vms_note (Elf_Internal_Note * pnote)
15553 {
15554   switch (pnote->type)
15555     {
15556     case NT_VMS_MHD:
15557       if (pnote->descsz > 36)
15558         {
15559           size_t l = strlen (pnote->descdata + 34);
15560           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15561           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15562           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15563           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15564         }
15565       else
15566         printf (_("    Invalid size\n"));
15567       break;
15568     case NT_VMS_LNM:
15569       printf (_("   Language: %s\n"), pnote->descdata);
15570       break;
15571 #ifdef BFD64
15572     case NT_VMS_FPMODE:
15573       printf (_("   Floating Point mode: "));
15574       printf ("0x%016" BFD_VMA_FMT "x\n",
15575               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15576       break;
15577     case NT_VMS_LINKTIME:
15578       printf (_("   Link time: "));
15579       print_vms_time
15580         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15581       printf ("\n");
15582       break;
15583     case NT_VMS_PATCHTIME:
15584       printf (_("   Patch time: "));
15585       print_vms_time
15586         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15587       printf ("\n");
15588       break;
15589     case NT_VMS_ORIG_DYN:
15590       printf (_("   Major id: %u,  minor id: %u\n"),
15591               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15592               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15593       printf (_("   Last modified  : "));
15594       print_vms_time
15595         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15596       printf (_("\n   Link flags  : "));
15597       printf ("0x%016" BFD_VMA_FMT "x\n",
15598               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15599       printf (_("   Header flags: 0x%08x\n"),
15600               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15601       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15602       break;
15603 #endif
15604     case NT_VMS_IMGNAM:
15605       printf (_("    Image name: %s\n"), pnote->descdata);
15606       break;
15607     case NT_VMS_GSTNAM:
15608       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15609       break;
15610     case NT_VMS_IMGID:
15611       printf (_("    Image id: %s\n"), pnote->descdata);
15612       break;
15613     case NT_VMS_LINKID:
15614       printf (_("    Linker id: %s\n"), pnote->descdata);
15615       break;
15616     default:
15617       break;
15618     }
15619   return 1;
15620 }
15621
15622 /* Note that by the ELF standard, the name field is already null byte
15623    terminated, and namesz includes the terminating null byte.
15624    I.E. the value of namesz for the name "FSF" is 4.
15625
15626    If the value of namesz is zero, there is no name present.  */
15627 static int
15628 process_note (Elf_Internal_Note * pnote)
15629 {
15630   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15631   const char * nt;
15632
15633   if (pnote->namesz == 0)
15634     /* If there is no note name, then use the default set of
15635        note type strings.  */
15636     nt = get_note_type (pnote->type);
15637
15638   else if (const_strneq (pnote->namedata, "GNU"))
15639     /* GNU-specific object file notes.  */
15640     nt = get_gnu_elf_note_type (pnote->type);
15641
15642   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15643     /* NetBSD-specific core file notes.  */
15644     nt = get_netbsd_elfcore_note_type (pnote->type);
15645
15646   else if (const_strneq (pnote->namedata, "NetBSD"))
15647     /* NetBSD-specific core file notes.  */
15648     return process_netbsd_elf_note (pnote);
15649
15650   else if (strneq (pnote->namedata, "SPU/", 4))
15651     {
15652       /* SPU-specific core file notes.  */
15653       nt = pnote->namedata + 4;
15654       name = "SPU";
15655     }
15656
15657   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15658     /* VMS/ia64-specific file notes.  */
15659     nt = get_ia64_vms_note_type (pnote->type);
15660
15661   else if (const_strneq (pnote->namedata, "stapsdt"))
15662     nt = get_stapsdt_note_type (pnote->type);
15663
15664   else
15665     /* Don't recognize this note name; just use the default set of
15666        note type strings.  */
15667     nt = get_note_type (pnote->type);
15668
15669   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15670
15671   if (const_strneq (pnote->namedata, "IPF/VMS"))
15672     return print_ia64_vms_note (pnote);
15673   else if (const_strneq (pnote->namedata, "GNU"))
15674     return print_gnu_note (pnote);
15675   else if (const_strneq (pnote->namedata, "stapsdt"))
15676     return print_stapsdt_note (pnote);
15677   else if (const_strneq (pnote->namedata, "CORE"))
15678     return print_core_note (pnote);
15679   else
15680     return 1;
15681 }
15682
15683
15684 static int
15685 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15686 {
15687   Elf_External_Note * pnotes;
15688   Elf_External_Note * external;
15689   char * end;
15690   int res = 1;
15691
15692   if (length <= 0)
15693     return 0;
15694
15695   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15696                                            _("notes"));
15697   if (pnotes == NULL)
15698     return 0;
15699
15700   external = pnotes;
15701
15702   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15703           (unsigned long) offset, (unsigned long) length);
15704   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15705
15706   end = (char *) pnotes + length;
15707   while ((char *) external < end)
15708     {
15709       Elf_Internal_Note inote;
15710       size_t min_notesz;
15711       char *next;
15712       char * temp = NULL;
15713       size_t data_remaining = end - (char *) external;
15714
15715       if (!is_ia64_vms ())
15716         {
15717           /* PR binutils/15191
15718              Make sure that there is enough data to read.  */
15719           min_notesz = offsetof (Elf_External_Note, name);
15720           if (data_remaining < min_notesz)
15721             {
15722               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15723                     (int) data_remaining);
15724               break;
15725             }
15726           inote.type     = BYTE_GET (external->type);
15727           inote.namesz   = BYTE_GET (external->namesz);
15728           inote.namedata = external->name;
15729           inote.descsz   = BYTE_GET (external->descsz);
15730           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15731           /* PR 17531: file: 3443835e.  */
15732           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15733             {
15734               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15735               inote.descdata = inote.namedata;
15736               inote.namesz   = 0;
15737             }
15738
15739           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15740           next = inote.descdata + align_power (inote.descsz, 2);
15741         }
15742       else
15743         {
15744           Elf64_External_VMS_Note *vms_external;
15745
15746           /* PR binutils/15191
15747              Make sure that there is enough data to read.  */
15748           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15749           if (data_remaining < min_notesz)
15750             {
15751               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15752                     (int) data_remaining);
15753               break;
15754             }
15755
15756           vms_external = (Elf64_External_VMS_Note *) external;
15757           inote.type     = BYTE_GET (vms_external->type);
15758           inote.namesz   = BYTE_GET (vms_external->namesz);
15759           inote.namedata = vms_external->name;
15760           inote.descsz   = BYTE_GET (vms_external->descsz);
15761           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15762           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15763           next = inote.descdata + align_power (inote.descsz, 3);
15764         }
15765
15766       if (inote.descdata < (char *) external + min_notesz
15767           || next < (char *) external + min_notesz
15768           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15769           || inote.namedata + inote.namesz < inote.namedata
15770           || inote.descdata + inote.descsz < inote.descdata
15771           || data_remaining < (size_t)(next - (char *) external))
15772         {
15773           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15774                 (unsigned long) ((char *) external - (char *) pnotes));
15775           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15776                 inote.type, inote.namesz, inote.descsz);
15777           break;
15778         }
15779
15780       external = (Elf_External_Note *) next;
15781
15782       /* Verify that name is null terminated.  It appears that at least
15783          one version of Linux (RedHat 6.0) generates corefiles that don't
15784          comply with the ELF spec by failing to include the null byte in
15785          namesz.  */
15786       if (inote.namedata[inote.namesz - 1] != '\0')
15787         {
15788           temp = (char *) malloc (inote.namesz + 1);
15789           if (temp == NULL)
15790             {
15791               error (_("Out of memory allocating space for inote name\n"));
15792               res = 0;
15793               break;
15794             }
15795
15796           strncpy (temp, inote.namedata, inote.namesz);
15797           temp[inote.namesz] = 0;
15798
15799           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15800           inote.namedata = temp;
15801         }
15802
15803       res &= process_note (& inote);
15804
15805       if (temp != NULL)
15806         {
15807           free (temp);
15808           temp = NULL;
15809         }
15810     }
15811
15812   free (pnotes);
15813
15814   return res;
15815 }
15816
15817 static int
15818 process_corefile_note_segments (FILE * file)
15819 {
15820   Elf_Internal_Phdr * segment;
15821   unsigned int i;
15822   int res = 1;
15823
15824   if (! get_program_headers (file))
15825       return 0;
15826
15827   for (i = 0, segment = program_headers;
15828        i < elf_header.e_phnum;
15829        i++, segment++)
15830     {
15831       if (segment->p_type == PT_NOTE)
15832         res &= process_corefile_note_segment (file,
15833                                               (bfd_vma) segment->p_offset,
15834                                               (bfd_vma) segment->p_filesz);
15835     }
15836
15837   return res;
15838 }
15839
15840 static int
15841 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15842 {
15843   Elf_External_Note * pnotes;
15844   Elf_External_Note * external;
15845   char * end;
15846   int res = 1;
15847
15848   if (length <= 0)
15849     return 0;
15850
15851   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15852                                            _("v850 notes"));
15853   if (pnotes == NULL)
15854     return 0;
15855
15856   external = pnotes;
15857   end = (char*) pnotes + length;
15858
15859   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15860           (unsigned long) offset, (unsigned long) length);
15861
15862   while ((char *) external + sizeof (Elf_External_Note) < end)
15863     {
15864       Elf_External_Note * next;
15865       Elf_Internal_Note inote;
15866
15867       inote.type     = BYTE_GET (external->type);
15868       inote.namesz   = BYTE_GET (external->namesz);
15869       inote.namedata = external->name;
15870       inote.descsz   = BYTE_GET (external->descsz);
15871       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15872       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15873
15874       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15875         {
15876           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15877           inote.descdata = inote.namedata;
15878           inote.namesz   = 0;
15879         }
15880
15881       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15882
15883       if (   ((char *) next > end)
15884           || ((char *) next <  (char *) pnotes))
15885         {
15886           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15887                 (unsigned long) ((char *) external - (char *) pnotes));
15888           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15889                 inote.type, inote.namesz, inote.descsz);
15890           break;
15891         }
15892
15893       external = next;
15894
15895       /* Prevent out-of-bounds indexing.  */
15896       if (   inote.namedata + inote.namesz > end
15897           || inote.namedata + inote.namesz < inote.namedata)
15898         {
15899           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15900                 (unsigned long) ((char *) external - (char *) pnotes));
15901           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15902                 inote.type, inote.namesz, inote.descsz);
15903           break;
15904         }
15905
15906       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15907
15908       if (! print_v850_note (& inote))
15909         {
15910           res = 0;
15911           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15912                   inote.namesz, inote.descsz);
15913         }
15914     }
15915
15916   free (pnotes);
15917
15918   return res;
15919 }
15920
15921 static int
15922 process_note_sections (FILE * file)
15923 {
15924   Elf_Internal_Shdr * section;
15925   unsigned long i;
15926   int n = 0;
15927   int res = 1;
15928
15929   for (i = 0, section = section_headers;
15930        i < elf_header.e_shnum && section != NULL;
15931        i++, section++)
15932     {
15933       if (section->sh_type == SHT_NOTE)
15934         {
15935           res &= process_corefile_note_segment (file,
15936                                                 (bfd_vma) section->sh_offset,
15937                                                 (bfd_vma) section->sh_size);
15938           n++;
15939         }
15940
15941       if ((   elf_header.e_machine == EM_V800
15942            || elf_header.e_machine == EM_V850
15943            || elf_header.e_machine == EM_CYGNUS_V850)
15944           && section->sh_type == SHT_RENESAS_INFO)
15945         {
15946           res &= process_v850_notes (file,
15947                                      (bfd_vma) section->sh_offset,
15948                                      (bfd_vma) section->sh_size);
15949           n++;
15950         }
15951     }
15952
15953   if (n == 0)
15954     /* Try processing NOTE segments instead.  */
15955     return process_corefile_note_segments (file);
15956
15957   return res;
15958 }
15959
15960 static int
15961 process_notes (FILE * file)
15962 {
15963   /* If we have not been asked to display the notes then do nothing.  */
15964   if (! do_notes)
15965     return 1;
15966
15967   if (elf_header.e_type != ET_CORE)
15968     return process_note_sections (file);
15969
15970   /* No program headers means no NOTE segment.  */
15971   if (elf_header.e_phnum > 0)
15972     return process_corefile_note_segments (file);
15973
15974   printf (_("No note segments present in the core file.\n"));
15975   return 1;
15976 }
15977
15978 static int
15979 process_arch_specific (FILE * file)
15980 {
15981   if (! do_arch)
15982     return 1;
15983
15984   switch (elf_header.e_machine)
15985     {
15986     case EM_ARM:
15987       return process_arm_specific (file);
15988     case EM_MIPS:
15989     case EM_MIPS_RS3_LE:
15990       return process_mips_specific (file);
15991       break;
15992     case EM_NDS32:
15993       return process_nds32_specific (file);
15994       break;
15995     case EM_PPC:
15996       return process_power_specific (file);
15997       break;
15998     case EM_S390:
15999     case EM_S390_OLD:
16000       return process_s390_specific (file);
16001       break;
16002     case EM_SPARC:
16003     case EM_SPARC32PLUS:
16004     case EM_SPARCV9:
16005       return process_sparc_specific (file);
16006       break;
16007     case EM_TI_C6000:
16008       return process_tic6x_specific (file);
16009       break;
16010     case EM_MSP430:
16011       return process_msp430x_specific (file);
16012     default:
16013       break;
16014     }
16015   return 1;
16016 }
16017
16018 static int
16019 get_file_header (FILE * file)
16020 {
16021   /* Read in the identity array.  */
16022   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
16023     return 0;
16024
16025   /* Determine how to read the rest of the header.  */
16026   switch (elf_header.e_ident[EI_DATA])
16027     {
16028     default: /* fall through */
16029     case ELFDATANONE: /* fall through */
16030     case ELFDATA2LSB:
16031       byte_get = byte_get_little_endian;
16032       byte_put = byte_put_little_endian;
16033       break;
16034     case ELFDATA2MSB:
16035       byte_get = byte_get_big_endian;
16036       byte_put = byte_put_big_endian;
16037       break;
16038     }
16039
16040   /* For now we only support 32 bit and 64 bit ELF files.  */
16041   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
16042
16043   /* Read in the rest of the header.  */
16044   if (is_32bit_elf)
16045     {
16046       Elf32_External_Ehdr ehdr32;
16047
16048       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16049         return 0;
16050
16051       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
16052       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
16053       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
16054       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
16055       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
16056       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
16057       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
16058       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
16059       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16060       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
16061       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16062       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
16063       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
16064     }
16065   else
16066     {
16067       Elf64_External_Ehdr ehdr64;
16068
16069       /* If we have been compiled with sizeof (bfd_vma) == 4, then
16070          we will not be able to cope with the 64bit data found in
16071          64 ELF files.  Detect this now and abort before we start
16072          overwriting things.  */
16073       if (sizeof (bfd_vma) < 8)
16074         {
16075           error (_("This instance of readelf has been built without support for a\n\
16076 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16077           return 0;
16078         }
16079
16080       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16081         return 0;
16082
16083       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
16084       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
16085       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
16086       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
16087       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
16088       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
16089       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
16090       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
16091       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16092       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
16093       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16094       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
16095       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
16096     }
16097
16098   if (elf_header.e_shoff)
16099     {
16100       /* There may be some extensions in the first section header.  Don't
16101          bomb if we can't read it.  */
16102       if (is_32bit_elf)
16103         get_32bit_section_headers (file, TRUE);
16104       else
16105         get_64bit_section_headers (file, TRUE);
16106     }
16107
16108   return 1;
16109 }
16110
16111 /* Process one ELF object file according to the command line options.
16112    This file may actually be stored in an archive.  The file is
16113    positioned at the start of the ELF object.  */
16114
16115 static int
16116 process_object (char * file_name, FILE * file)
16117 {
16118   unsigned int i;
16119
16120   if (! get_file_header (file))
16121     {
16122       error (_("%s: Failed to read file header\n"), file_name);
16123       return 1;
16124     }
16125
16126   /* Initialise per file variables.  */
16127   for (i = ARRAY_SIZE (version_info); i--;)
16128     version_info[i] = 0;
16129
16130   for (i = ARRAY_SIZE (dynamic_info); i--;)
16131     dynamic_info[i] = 0;
16132   dynamic_info_DT_GNU_HASH = 0;
16133
16134   /* Process the file.  */
16135   if (show_name)
16136     printf (_("\nFile: %s\n"), file_name);
16137
16138   /* Initialise the dump_sects array from the cmdline_dump_sects array.
16139      Note we do this even if cmdline_dump_sects is empty because we
16140      must make sure that the dump_sets array is zeroed out before each
16141      object file is processed.  */
16142   if (num_dump_sects > num_cmdline_dump_sects)
16143     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
16144
16145   if (num_cmdline_dump_sects > 0)
16146     {
16147       if (num_dump_sects == 0)
16148         /* A sneaky way of allocating the dump_sects array.  */
16149         request_dump_bynumber (num_cmdline_dump_sects, 0);
16150
16151       assert (num_dump_sects >= num_cmdline_dump_sects);
16152       memcpy (dump_sects, cmdline_dump_sects,
16153               num_cmdline_dump_sects * sizeof (* dump_sects));
16154     }
16155
16156   if (! process_file_header ())
16157     return 1;
16158
16159   if (! process_section_headers (file))
16160     {
16161       /* Without loaded section headers we cannot process lots of
16162          things.  */
16163       do_unwind = do_version = do_dump = do_arch = 0;
16164
16165       if (! do_using_dynamic)
16166         do_syms = do_dyn_syms = do_reloc = 0;
16167     }
16168
16169   if (! process_section_groups (file))
16170     {
16171       /* Without loaded section groups we cannot process unwind.  */
16172       do_unwind = 0;
16173     }
16174
16175   if (process_program_headers (file))
16176     process_dynamic_section (file);
16177
16178   process_relocs (file);
16179
16180   process_unwind (file);
16181
16182   process_symbol_table (file);
16183
16184   process_syminfo (file);
16185
16186   process_version_sections (file);
16187
16188   process_section_contents (file);
16189
16190   process_notes (file);
16191
16192   process_gnu_liblist (file);
16193
16194   process_arch_specific (file);
16195
16196   if (program_headers)
16197     {
16198       free (program_headers);
16199       program_headers = NULL;
16200     }
16201
16202   if (section_headers)
16203     {
16204       free (section_headers);
16205       section_headers = NULL;
16206     }
16207
16208   if (string_table)
16209     {
16210       free (string_table);
16211       string_table = NULL;
16212       string_table_length = 0;
16213     }
16214
16215   if (dynamic_strings)
16216     {
16217       free (dynamic_strings);
16218       dynamic_strings = NULL;
16219       dynamic_strings_length = 0;
16220     }
16221
16222   if (dynamic_symbols)
16223     {
16224       free (dynamic_symbols);
16225       dynamic_symbols = NULL;
16226       num_dynamic_syms = 0;
16227     }
16228
16229   if (dynamic_syminfo)
16230     {
16231       free (dynamic_syminfo);
16232       dynamic_syminfo = NULL;
16233     }
16234
16235   if (dynamic_section)
16236     {
16237       free (dynamic_section);
16238       dynamic_section = NULL;
16239     }
16240
16241   if (section_headers_groups)
16242     {
16243       free (section_headers_groups);
16244       section_headers_groups = NULL;
16245     }
16246
16247   if (section_groups)
16248     {
16249       struct group_list * g;
16250       struct group_list * next;
16251
16252       for (i = 0; i < group_count; i++)
16253         {
16254           for (g = section_groups [i].root; g != NULL; g = next)
16255             {
16256               next = g->next;
16257               free (g);
16258             }
16259         }
16260
16261       free (section_groups);
16262       section_groups = NULL;
16263     }
16264
16265   free_debug_memory ();
16266
16267   return 0;
16268 }
16269
16270 /* Process an ELF archive.
16271    On entry the file is positioned just after the ARMAG string.  */
16272
16273 static int
16274 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16275 {
16276   struct archive_info arch;
16277   struct archive_info nested_arch;
16278   size_t got;
16279   int ret;
16280
16281   show_name = 1;
16282
16283   /* The ARCH structure is used to hold information about this archive.  */
16284   arch.file_name = NULL;
16285   arch.file = NULL;
16286   arch.index_array = NULL;
16287   arch.sym_table = NULL;
16288   arch.longnames = NULL;
16289
16290   /* The NESTED_ARCH structure is used as a single-item cache of information
16291      about a nested archive (when members of a thin archive reside within
16292      another regular archive file).  */
16293   nested_arch.file_name = NULL;
16294   nested_arch.file = NULL;
16295   nested_arch.index_array = NULL;
16296   nested_arch.sym_table = NULL;
16297   nested_arch.longnames = NULL;
16298
16299   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16300     {
16301       ret = 1;
16302       goto out;
16303     }
16304
16305   if (do_archive_index)
16306     {
16307       if (arch.sym_table == NULL)
16308         error (_("%s: unable to dump the index as none was found\n"), file_name);
16309       else
16310         {
16311           unsigned long i, l;
16312           unsigned long current_pos;
16313
16314           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16315                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16316           current_pos = ftell (file);
16317
16318           for (i = l = 0; i < arch.index_num; i++)
16319             {
16320               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16321                 {
16322                   char * member_name;
16323
16324                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16325
16326                   if (member_name != NULL)
16327                     {
16328                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16329
16330                       if (qualified_name != NULL)
16331                         {
16332                           printf (_("Contents of binary %s at offset "), qualified_name);
16333                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16334                           putchar ('\n');
16335                           free (qualified_name);
16336                         }
16337                     }
16338                 }
16339
16340               if (l >= arch.sym_size)
16341                 {
16342                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16343                          file_name);
16344                   break;
16345                 }
16346               /* PR 17531: file: 0b6630b2.  */
16347               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16348               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16349             }
16350
16351           if (arch.uses_64bit_indicies)
16352             l = (l + 7) & ~ 7;
16353           else
16354             l += l & 1;
16355
16356           if (l < arch.sym_size)
16357             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16358                    file_name, arch.sym_size - l);
16359
16360           if (fseek (file, current_pos, SEEK_SET) != 0)
16361             {
16362               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16363               ret = 1;
16364               goto out;
16365             }
16366         }
16367
16368       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16369           && !do_segments && !do_header && !do_dump && !do_version
16370           && !do_histogram && !do_debugging && !do_arch && !do_notes
16371           && !do_section_groups && !do_dyn_syms)
16372         {
16373           ret = 0; /* Archive index only.  */
16374           goto out;
16375         }
16376     }
16377
16378   ret = 0;
16379
16380   while (1)
16381     {
16382       char * name;
16383       size_t namelen;
16384       char * qualified_name;
16385
16386       /* Read the next archive header.  */
16387       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16388         {
16389           error (_("%s: failed to seek to next archive header\n"), file_name);
16390           return 1;
16391         }
16392       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16393       if (got != sizeof arch.arhdr)
16394         {
16395           if (got == 0)
16396             break;
16397           error (_("%s: failed to read archive header\n"), file_name);
16398           ret = 1;
16399           break;
16400         }
16401       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16402         {
16403           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16404           ret = 1;
16405           break;
16406         }
16407
16408       arch.next_arhdr_offset += sizeof arch.arhdr;
16409
16410       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16411       if (archive_file_size & 01)
16412         ++archive_file_size;
16413
16414       name = get_archive_member_name (&arch, &nested_arch);
16415       if (name == NULL)
16416         {
16417           error (_("%s: bad archive file name\n"), file_name);
16418           ret = 1;
16419           break;
16420         }
16421       namelen = strlen (name);
16422
16423       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16424       if (qualified_name == NULL)
16425         {
16426           error (_("%s: bad archive file name\n"), file_name);
16427           ret = 1;
16428           break;
16429         }
16430
16431       if (is_thin_archive && arch.nested_member_origin == 0)
16432         {
16433           /* This is a proxy for an external member of a thin archive.  */
16434           FILE * member_file;
16435           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16436           if (member_file_name == NULL)
16437             {
16438               ret = 1;
16439               break;
16440             }
16441
16442           member_file = fopen (member_file_name, "rb");
16443           if (member_file == NULL)
16444             {
16445               error (_("Input file '%s' is not readable.\n"), member_file_name);
16446               free (member_file_name);
16447               ret = 1;
16448               break;
16449             }
16450
16451           archive_file_offset = arch.nested_member_origin;
16452
16453           ret |= process_object (qualified_name, member_file);
16454
16455           fclose (member_file);
16456           free (member_file_name);
16457         }
16458       else if (is_thin_archive)
16459         {
16460           /* PR 15140: Allow for corrupt thin archives.  */
16461           if (nested_arch.file == NULL)
16462             {
16463               error (_("%s: contains corrupt thin archive: %s\n"),
16464                      file_name, name);
16465               ret = 1;
16466               break;
16467             }
16468
16469           /* This is a proxy for a member of a nested archive.  */
16470           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16471
16472           /* The nested archive file will have been opened and setup by
16473              get_archive_member_name.  */
16474           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16475             {
16476               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16477               ret = 1;
16478               break;
16479             }
16480
16481           ret |= process_object (qualified_name, nested_arch.file);
16482         }
16483       else
16484         {
16485           archive_file_offset = arch.next_arhdr_offset;
16486           arch.next_arhdr_offset += archive_file_size;
16487
16488           ret |= process_object (qualified_name, file);
16489         }
16490
16491       if (dump_sects != NULL)
16492         {
16493           free (dump_sects);
16494           dump_sects = NULL;
16495           num_dump_sects = 0;
16496         }
16497
16498       free (qualified_name);
16499     }
16500
16501  out:
16502   if (nested_arch.file != NULL)
16503     fclose (nested_arch.file);
16504   release_archive (&nested_arch);
16505   release_archive (&arch);
16506
16507   return ret;
16508 }
16509
16510 static int
16511 process_file (char * file_name)
16512 {
16513   FILE * file;
16514   struct stat statbuf;
16515   char armag[SARMAG];
16516   int ret;
16517
16518   if (stat (file_name, &statbuf) < 0)
16519     {
16520       if (errno == ENOENT)
16521         error (_("'%s': No such file\n"), file_name);
16522       else
16523         error (_("Could not locate '%s'.  System error message: %s\n"),
16524                file_name, strerror (errno));
16525       return 1;
16526     }
16527
16528   if (! S_ISREG (statbuf.st_mode))
16529     {
16530       error (_("'%s' is not an ordinary file\n"), file_name);
16531       return 1;
16532     }
16533
16534   file = fopen (file_name, "rb");
16535   if (file == NULL)
16536     {
16537       error (_("Input file '%s' is not readable.\n"), file_name);
16538       return 1;
16539     }
16540
16541   if (fread (armag, SARMAG, 1, file) != 1)
16542     {
16543       error (_("%s: Failed to read file's magic number\n"), file_name);
16544       fclose (file);
16545       return 1;
16546     }
16547
16548   current_file_size = (bfd_size_type) statbuf.st_size;
16549
16550   if (memcmp (armag, ARMAG, SARMAG) == 0)
16551     ret = process_archive (file_name, file, FALSE);
16552   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16553     ret = process_archive (file_name, file, TRUE);
16554   else
16555     {
16556       if (do_archive_index)
16557         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16558                file_name);
16559
16560       rewind (file);
16561       archive_file_size = archive_file_offset = 0;
16562       ret = process_object (file_name, file);
16563     }
16564
16565   fclose (file);
16566
16567   current_file_size = 0;
16568   return ret;
16569 }
16570
16571 #ifdef SUPPORT_DISASSEMBLY
16572 /* Needed by the i386 disassembler.  For extra credit, someone could
16573    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16574    symbols.  */
16575
16576 void
16577 print_address (unsigned int addr, FILE * outfile)
16578 {
16579   fprintf (outfile,"0x%8.8x", addr);
16580 }
16581
16582 /* Needed by the i386 disassembler.  */
16583 void
16584 db_task_printsym (unsigned int addr)
16585 {
16586   print_address (addr, stderr);
16587 }
16588 #endif
16589
16590 int
16591 main (int argc, char ** argv)
16592 {
16593   int err;
16594
16595 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16596   setlocale (LC_MESSAGES, "");
16597 #endif
16598 #if defined (HAVE_SETLOCALE)
16599   setlocale (LC_CTYPE, "");
16600 #endif
16601   bindtextdomain (PACKAGE, LOCALEDIR);
16602   textdomain (PACKAGE);
16603
16604   expandargv (&argc, &argv);
16605
16606   parse_args (argc, argv);
16607
16608   if (num_dump_sects > 0)
16609     {
16610       /* Make a copy of the dump_sects array.  */
16611       cmdline_dump_sects = (dump_type *)
16612           malloc (num_dump_sects * sizeof (* dump_sects));
16613       if (cmdline_dump_sects == NULL)
16614         error (_("Out of memory allocating dump request table.\n"));
16615       else
16616         {
16617           memcpy (cmdline_dump_sects, dump_sects,
16618                   num_dump_sects * sizeof (* dump_sects));
16619           num_cmdline_dump_sects = num_dump_sects;
16620         }
16621     }
16622
16623   if (optind < (argc - 1))
16624     show_name = 1;
16625   else if (optind >= argc)
16626     {
16627       warn (_("Nothing to do.\n"));
16628       usage (stderr);
16629     }
16630
16631   err = 0;
16632   while (optind < argc)
16633     err |= process_file (argv[optind++]);
16634
16635   if (dump_sects != NULL)
16636     free (dump_sects);
16637   if (cmdline_dump_sects != NULL)
16638     free (cmdline_dump_sects);
16639
16640   return err;
16641 }