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