binutils/readelf.c

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