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                 int check_def, check_need;
9893                 char * name;
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                       check_def = 1;
9921                       check_need = 1;
9922                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9923                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9924                              != SHT_NOBITS)
9925                         {
9926                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9927                             check_def = 0;
9928                           else
9929                             check_need = 0;
9930                         }
9931
9932                       if (check_need
9933                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9934                         {
9935                           Elf_Internal_Verneed ivn;
9936                           unsigned long offset;
9937
9938                           offset = offset_from_vma
9939                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9940                              sizeof (Elf_External_Verneed));
9941
9942                           do
9943                             {
9944                               Elf_Internal_Vernaux ivna;
9945                               Elf_External_Verneed evn;
9946                               Elf_External_Vernaux evna;
9947                               unsigned long a_off;
9948
9949                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9950                                             _("version need")) == NULL)
9951                                 break;
9952
9953                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9954                               ivn.vn_next = BYTE_GET (evn.vn_next);
9955
9956                               a_off = offset + ivn.vn_aux;
9957
9958                               do
9959                                 {
9960                                   if (get_data (&evna, file, a_off, sizeof (evna),
9961                                                 1, _("version need aux (2)")) == NULL)
9962                                     {
9963                                       ivna.vna_next  = 0;
9964                                       ivna.vna_other = 0;
9965                                     }
9966                                   else
9967                                     {
9968                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9969                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9970                                     }
9971
9972                                   a_off += ivna.vna_next;
9973                                 }
9974                               while (ivna.vna_other != data[cnt + j]
9975                                      && ivna.vna_next != 0);
9976
9977                               if (ivna.vna_other == data[cnt + j])
9978                                 {
9979                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9980
9981                                   if (ivna.vna_name >= string_sec->sh_size)
9982                                     name = _("*invalid*");
9983                                   else
9984                                     name = strtab + ivna.vna_name;
9985                                   nn += printf ("(%s%-*s",
9986                                                 name,
9987                                                 12 - (int) strlen (name),
9988                                                 ")");
9989                                   check_def = 0;
9990                                   break;
9991                                 }
9992
9993                               offset += ivn.vn_next;
9994                             }
9995                           while (ivn.vn_next);
9996                         }
9997
9998                       if (check_def && data[cnt + j] != 0x8001
9999                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10000                         {
10001                           Elf_Internal_Verdef ivd;
10002                           Elf_External_Verdef evd;
10003                           unsigned long offset;
10004
10005                           offset = offset_from_vma
10006                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10007                              sizeof evd);
10008
10009                           do
10010                             {
10011                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10012                                             _("version def")) == NULL)
10013                                 {
10014                                   ivd.vd_next = 0;
10015                                   /* PR 17531: file: 046-1082287-0.004.  */
10016                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10017                                   break;
10018                                 }
10019                               else
10020                                 {
10021                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10022                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10023                                 }
10024
10025                               offset += ivd.vd_next;
10026                             }
10027                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10028                                  && ivd.vd_next != 0);
10029
10030                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10031                             {
10032                               Elf_External_Verdaux evda;
10033                               Elf_Internal_Verdaux ivda;
10034
10035                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10036
10037                               if (get_data (&evda, file,
10038                                             offset - ivd.vd_next + ivd.vd_aux,
10039                                             sizeof (evda), 1,
10040                                             _("version def aux")) == NULL)
10041                                 break;
10042
10043                               ivda.vda_name = BYTE_GET (evda.vda_name);
10044
10045                               if (ivda.vda_name >= string_sec->sh_size)
10046                                 name = _("*invalid*");
10047                               else
10048                                 name = strtab + ivda.vda_name;
10049                               nn += printf ("(%s%-*s",
10050                                             name,
10051                                             12 - (int) strlen (name),
10052                                             ")");
10053                             }
10054                         }
10055
10056                       if (nn < 18)
10057                         printf ("%*c", 18 - nn, ' ');
10058                     }
10059
10060                 putchar ('\n');
10061               }
10062
10063             free (data);
10064             free (strtab);
10065             free (symbols);
10066           }
10067           break;
10068
10069         default:
10070           break;
10071         }
10072     }
10073
10074   if (! found)
10075     printf (_("\nNo version information found in this file.\n"));
10076
10077   return 1;
10078 }
10079
10080 static const char *
10081 get_symbol_binding (unsigned int binding)
10082 {
10083   static char buff[32];
10084
10085   switch (binding)
10086     {
10087     case STB_LOCAL:     return "LOCAL";
10088     case STB_GLOBAL:    return "GLOBAL";
10089     case STB_WEAK:      return "WEAK";
10090     default:
10091       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10092         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10093                   binding);
10094       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10095         {
10096           if (binding == STB_GNU_UNIQUE
10097               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10098                   /* GNU is still using the default value 0.  */
10099                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10100             return "UNIQUE";
10101           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10102         }
10103       else
10104         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10105       return buff;
10106     }
10107 }
10108
10109 static const char *
10110 get_symbol_type (unsigned int type)
10111 {
10112   static char buff[32];
10113
10114   switch (type)
10115     {
10116     case STT_NOTYPE:    return "NOTYPE";
10117     case STT_OBJECT:    return "OBJECT";
10118     case STT_FUNC:      return "FUNC";
10119     case STT_SECTION:   return "SECTION";
10120     case STT_FILE:      return "FILE";
10121     case STT_COMMON:    return "COMMON";
10122     case STT_TLS:       return "TLS";
10123     case STT_RELC:      return "RELC";
10124     case STT_SRELC:     return "SRELC";
10125     default:
10126       if (type >= STT_LOPROC && type <= STT_HIPROC)
10127         {
10128           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10129             return "THUMB_FUNC";
10130
10131           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10132             return "REGISTER";
10133
10134           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10135             return "PARISC_MILLI";
10136
10137           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10138         }
10139       else if (type >= STT_LOOS && type <= STT_HIOS)
10140         {
10141           if (elf_header.e_machine == EM_PARISC)
10142             {
10143               if (type == STT_HP_OPAQUE)
10144                 return "HP_OPAQUE";
10145               if (type == STT_HP_STUB)
10146                 return "HP_STUB";
10147             }
10148
10149           if (type == STT_GNU_IFUNC
10150               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10151                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10152                   /* GNU is still using the default value 0.  */
10153                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10154             return "IFUNC";
10155
10156           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10157         }
10158       else
10159         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10160       return buff;
10161     }
10162 }
10163
10164 static const char *
10165 get_symbol_visibility (unsigned int visibility)
10166 {
10167   switch (visibility)
10168     {
10169     case STV_DEFAULT:   return "DEFAULT";
10170     case STV_INTERNAL:  return "INTERNAL";
10171     case STV_HIDDEN:    return "HIDDEN";
10172     case STV_PROTECTED: return "PROTECTED";
10173     default:
10174       error (_("Unrecognized visibility value: %u"), visibility);
10175       return _("<unknown>");
10176     }
10177 }
10178
10179 static const char *
10180 get_mips_symbol_other (unsigned int other)
10181 {
10182   switch (other)
10183     {
10184     case STO_OPTIONAL:
10185       return "OPTIONAL";
10186     case STO_MIPS_PLT:
10187       return "MIPS PLT";
10188     case STO_MIPS_PIC:
10189       return "MIPS PIC";
10190     case STO_MICROMIPS:
10191       return "MICROMIPS";
10192     case STO_MICROMIPS | STO_MIPS_PIC:
10193       return "MICROMIPS, MIPS PIC";
10194     case STO_MIPS16:
10195       return "MIPS16";
10196     default:
10197       return NULL;
10198     }
10199 }
10200
10201 static const char *
10202 get_ia64_symbol_other (unsigned int other)
10203 {
10204   if (is_ia64_vms ())
10205     {
10206       static char res[32];
10207
10208       res[0] = 0;
10209
10210       /* Function types is for images and .STB files only.  */
10211       switch (elf_header.e_type)
10212         {
10213         case ET_DYN:
10214         case ET_EXEC:
10215           switch (VMS_ST_FUNC_TYPE (other))
10216             {
10217             case VMS_SFT_CODE_ADDR:
10218               strcat (res, " CA");
10219               break;
10220             case VMS_SFT_SYMV_IDX:
10221               strcat (res, " VEC");
10222               break;
10223             case VMS_SFT_FD:
10224               strcat (res, " FD");
10225               break;
10226             case VMS_SFT_RESERVE:
10227               strcat (res, " RSV");
10228               break;
10229             default:
10230               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10231                     VMS_ST_FUNC_TYPE (other));
10232               strcat (res, " <unknown>");
10233               break;
10234             }
10235           break;
10236         default:
10237           break;
10238         }
10239       switch (VMS_ST_LINKAGE (other))
10240         {
10241         case VMS_STL_IGNORE:
10242           strcat (res, " IGN");
10243           break;
10244         case VMS_STL_RESERVE:
10245           strcat (res, " RSV");
10246           break;
10247         case VMS_STL_STD:
10248           strcat (res, " STD");
10249           break;
10250         case VMS_STL_LNK:
10251           strcat (res, " LNK");
10252           break;
10253         default:
10254           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10255                 VMS_ST_LINKAGE (other));
10256           strcat (res, " <unknown>");
10257           break;
10258         }
10259
10260       if (res[0] != 0)
10261         return res + 1;
10262       else
10263         return res;
10264     }
10265   return NULL;
10266 }
10267
10268 static const char *
10269 get_ppc64_symbol_other (unsigned int other)
10270 {
10271   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10272     {
10273       static char buf[32];
10274       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10275                 PPC64_LOCAL_ENTRY_OFFSET (other));
10276       return buf;
10277     }
10278   return NULL;
10279 }
10280
10281 static const char *
10282 get_symbol_other (unsigned int other)
10283 {
10284   const char * result = NULL;
10285   static char buff [32];
10286
10287   if (other == 0)
10288     return "";
10289
10290   switch (elf_header.e_machine)
10291     {
10292     case EM_MIPS:
10293       result = get_mips_symbol_other (other);
10294       break;
10295     case EM_IA_64:
10296       result = get_ia64_symbol_other (other);
10297       break;
10298     case EM_PPC64:
10299       result = get_ppc64_symbol_other (other);
10300       break;
10301     default:
10302       break;
10303     }
10304
10305   if (result)
10306     return result;
10307
10308   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10309   return buff;
10310 }
10311
10312 static const char *
10313 get_symbol_index_type (unsigned int type)
10314 {
10315   static char buff[32];
10316
10317   switch (type)
10318     {
10319     case SHN_UNDEF:     return "UND";
10320     case SHN_ABS:       return "ABS";
10321     case SHN_COMMON:    return "COM";
10322     default:
10323       if (type == SHN_IA_64_ANSI_COMMON
10324           && elf_header.e_machine == EM_IA_64
10325           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10326         return "ANSI_COM";
10327       else if ((elf_header.e_machine == EM_X86_64
10328                 || elf_header.e_machine == EM_L1OM
10329                 || elf_header.e_machine == EM_K1OM)
10330                && type == SHN_X86_64_LCOMMON)
10331         return "LARGE_COM";
10332       else if ((type == SHN_MIPS_SCOMMON
10333                 && elf_header.e_machine == EM_MIPS)
10334                || (type == SHN_TIC6X_SCOMMON
10335                    && elf_header.e_machine == EM_TI_C6000))
10336         return "SCOM";
10337       else if (type == SHN_MIPS_SUNDEFINED
10338                && elf_header.e_machine == EM_MIPS)
10339         return "SUND";
10340       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10341         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10342       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10343         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10344       else if (type >= SHN_LORESERVE)
10345         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10346       else if (type >= elf_header.e_shnum)
10347         sprintf (buff, _("bad section index[%3d]"), type);
10348       else
10349         sprintf (buff, "%3d", type);
10350       break;
10351     }
10352
10353   return buff;
10354 }
10355
10356 static bfd_vma *
10357 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10358 {
10359   unsigned char * e_data;
10360   bfd_vma * i_data;
10361
10362   /* If the size_t type is smaller than the bfd_size_type, eg because
10363      you are building a 32-bit tool on a 64-bit host, then make sure
10364      that when (number) is cast to (size_t) no information is lost.  */
10365   if (sizeof (size_t) < sizeof (bfd_size_type)
10366       && (bfd_size_type) ((size_t) number) != number)
10367     {
10368       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10369              (unsigned long long) number, ent_size);
10370       return NULL;
10371     }
10372
10373   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10374      attempting to allocate memory when the read is bound to fail.  */
10375   if (ent_size * number > current_file_size)
10376     {
10377       error (_("Invalid number of dynamic entries: %llu\n"),
10378              (unsigned long long) number);
10379       return NULL;
10380     }
10381
10382   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10383   if (e_data == NULL)
10384     {
10385       error (_("Out of memory reading %llu dynamic entries\n"),
10386              (unsigned long long) number);
10387       return NULL;
10388     }
10389
10390   if (fread (e_data, ent_size, (size_t) number, file) != number)
10391     {
10392       error (_("Unable to read in %llu bytes of dynamic data\n"),
10393              (unsigned long long) (number * ent_size));
10394       free (e_data);
10395       return NULL;
10396     }
10397
10398   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10399   if (i_data == NULL)
10400     {
10401       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10402              (unsigned long long) number);
10403       free (e_data);
10404       return NULL;
10405     }
10406
10407   while (number--)
10408     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10409
10410   free (e_data);
10411
10412   return i_data;
10413 }
10414
10415 static void
10416 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10417 {
10418   Elf_Internal_Sym * psym;
10419   int n;
10420
10421   n = print_vma (si, DEC_5);
10422   if (n < 5)
10423     fputs (&"     "[n], stdout);
10424   printf (" %3lu: ", hn);
10425
10426   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10427     {
10428       printf (_("<No info available for dynamic symbol number %lu>\n"),
10429               (unsigned long) si);
10430       return;
10431     }
10432
10433   psym = dynamic_symbols + si;
10434   print_vma (psym->st_value, LONG_HEX);
10435   putchar (' ');
10436   print_vma (psym->st_size, DEC_5);
10437
10438   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10439   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10440   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10441   /* Check to see if any other bits in the st_other field are set.
10442      Note - displaying this information disrupts the layout of the
10443      table being generated, but for the moment this case is very
10444      rare.  */
10445   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10446     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10447   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10448   if (VALID_DYNAMIC_NAME (psym->st_name))
10449     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10450   else
10451     printf (_(" <corrupt: %14ld>"), psym->st_name);
10452   putchar ('\n');
10453 }
10454
10455 static const char *
10456 get_symbol_version_string (FILE *file, int is_dynsym,
10457                            const char *strtab,
10458                            unsigned long int strtab_size,
10459                            unsigned int si, Elf_Internal_Sym *psym,
10460                            enum versioned_symbol_info *sym_info,
10461                            unsigned short *vna_other)
10462 {
10463   const char *version_string = NULL;
10464
10465   if (is_dynsym
10466       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10467     {
10468       unsigned char data[2];
10469       unsigned short vers_data;
10470       unsigned long offset;
10471       int is_nobits;
10472       int check_def;
10473
10474       offset = offset_from_vma
10475         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10476          sizeof data + si * sizeof (vers_data));
10477
10478       if (get_data (&data, file, offset + si * sizeof (vers_data),
10479                     sizeof (data), 1, _("version data")) == NULL)
10480         return NULL;
10481
10482       vers_data = byte_get (data, 2);
10483
10484       is_nobits = (section_headers != NULL
10485                    && psym->st_shndx < elf_header.e_shnum
10486                    && section_headers[psym->st_shndx].sh_type
10487                    == SHT_NOBITS);
10488
10489       check_def = (psym->st_shndx != SHN_UNDEF);
10490
10491       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10492         {
10493           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10494               && (is_nobits || ! check_def))
10495             {
10496               Elf_External_Verneed evn;
10497               Elf_Internal_Verneed ivn;
10498               Elf_Internal_Vernaux ivna;
10499
10500               /* We must test both.  */
10501               offset = offset_from_vma
10502                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10503                  sizeof evn);
10504
10505               do
10506                 {
10507                   unsigned long vna_off;
10508
10509                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10510                                 _("version need")) == NULL)
10511                     {
10512                       ivna.vna_next = 0;
10513                       ivna.vna_other = 0;
10514                       ivna.vna_name = 0;
10515                       break;
10516                     }
10517
10518                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10519                   ivn.vn_next = BYTE_GET (evn.vn_next);
10520
10521                   vna_off = offset + ivn.vn_aux;
10522
10523                   do
10524                     {
10525                       Elf_External_Vernaux evna;
10526
10527                       if (get_data (&evna, file, vna_off,
10528                                     sizeof (evna), 1,
10529                                     _("version need aux (3)")) == NULL)
10530                         {
10531                           ivna.vna_next = 0;
10532                           ivna.vna_other = 0;
10533                           ivna.vna_name = 0;
10534                         }
10535                       else
10536                         {
10537                           ivna.vna_other = BYTE_GET (evna.vna_other);
10538                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10539                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10540                         }
10541
10542                       vna_off += ivna.vna_next;
10543                     }
10544                   while (ivna.vna_other != vers_data
10545                          && ivna.vna_next != 0);
10546
10547                   if (ivna.vna_other == vers_data)
10548                     break;
10549
10550                   offset += ivn.vn_next;
10551                 }
10552               while (ivn.vn_next != 0);
10553
10554               if (ivna.vna_other == vers_data)
10555                 {
10556                   *sym_info = symbol_undefined;
10557                   *vna_other = ivna.vna_other;
10558                   version_string = (ivna.vna_name < strtab_size
10559                                     ? strtab + ivna.vna_name
10560                                     : _("<corrupt>"));
10561                   check_def = 0;
10562                 }
10563               else if (! is_nobits)
10564                 error (_("bad dynamic symbol\n"));
10565               else
10566                 check_def = 1;
10567             }
10568
10569           if (check_def)
10570             {
10571               if (vers_data != 0x8001
10572                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10573                 {
10574                   Elf_Internal_Verdef ivd;
10575                   Elf_Internal_Verdaux ivda;
10576                   Elf_External_Verdaux evda;
10577                   unsigned long off;
10578
10579                   off = offset_from_vma
10580                     (file,
10581                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10582                      sizeof (Elf_External_Verdef));
10583
10584                   do
10585                     {
10586                       Elf_External_Verdef evd;
10587
10588                       if (get_data (&evd, file, off, sizeof (evd),
10589                                     1, _("version def")) == NULL)
10590                         {
10591                           ivd.vd_ndx = 0;
10592                           ivd.vd_aux = 0;
10593                           ivd.vd_next = 0;
10594                         }
10595                       else
10596                         {
10597                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10598                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10599                           ivd.vd_next = BYTE_GET (evd.vd_next);
10600                         }
10601
10602                       off += ivd.vd_next;
10603                     }
10604                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10605                          && ivd.vd_next != 0);
10606
10607                   off -= ivd.vd_next;
10608                   off += ivd.vd_aux;
10609
10610                   if (get_data (&evda, file, off, sizeof (evda),
10611                                 1, _("version def aux")) == NULL)
10612                     return version_string;
10613
10614                   ivda.vda_name = BYTE_GET (evda.vda_name);
10615
10616                   if (psym->st_name != ivda.vda_name)
10617                     {
10618                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10619                                    ? symbol_hidden : symbol_public);
10620                       version_string = (ivda.vda_name < strtab_size
10621                                         ? strtab + ivda.vda_name
10622                                         : _("<corrupt>"));
10623                     }
10624                 }
10625             }
10626         }
10627     }
10628   return version_string;
10629 }
10630
10631 /* Dump the symbol table.  */
10632 static int
10633 process_symbol_table (FILE * file)
10634 {
10635   Elf_Internal_Shdr * section;
10636   bfd_size_type nbuckets = 0;
10637   bfd_size_type nchains = 0;
10638   bfd_vma * buckets = NULL;
10639   bfd_vma * chains = NULL;
10640   bfd_vma ngnubuckets = 0;
10641   bfd_vma * gnubuckets = NULL;
10642   bfd_vma * gnuchains = NULL;
10643   bfd_vma gnusymidx = 0;
10644   bfd_size_type ngnuchains = 0;
10645
10646   if (!do_syms && !do_dyn_syms && !do_histogram)
10647     return 1;
10648
10649   if (dynamic_info[DT_HASH]
10650       && (do_histogram
10651           || (do_using_dynamic
10652               && !do_dyn_syms
10653               && dynamic_strings != NULL)))
10654     {
10655       unsigned char nb[8];
10656       unsigned char nc[8];
10657       unsigned int hash_ent_size = 4;
10658
10659       if ((elf_header.e_machine == EM_ALPHA
10660            || elf_header.e_machine == EM_S390
10661            || elf_header.e_machine == EM_S390_OLD)
10662           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10663         hash_ent_size = 8;
10664
10665       if (fseek (file,
10666                  (archive_file_offset
10667                   + offset_from_vma (file, dynamic_info[DT_HASH],
10668                                      sizeof nb + sizeof nc)),
10669                  SEEK_SET))
10670         {
10671           error (_("Unable to seek to start of dynamic information\n"));
10672           goto no_hash;
10673         }
10674
10675       if (fread (nb, hash_ent_size, 1, file) != 1)
10676         {
10677           error (_("Failed to read in number of buckets\n"));
10678           goto no_hash;
10679         }
10680
10681       if (fread (nc, hash_ent_size, 1, file) != 1)
10682         {
10683           error (_("Failed to read in number of chains\n"));
10684           goto no_hash;
10685         }
10686
10687       nbuckets = byte_get (nb, hash_ent_size);
10688       nchains  = byte_get (nc, hash_ent_size);
10689
10690       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10691       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10692
10693     no_hash:
10694       if (buckets == NULL || chains == NULL)
10695         {
10696           if (do_using_dynamic)
10697             return 0;
10698           free (buckets);
10699           free (chains);
10700           buckets = NULL;
10701           chains = NULL;
10702           nbuckets = 0;
10703           nchains = 0;
10704         }
10705     }
10706
10707   if (dynamic_info_DT_GNU_HASH
10708       && (do_histogram
10709           || (do_using_dynamic
10710               && !do_dyn_syms
10711               && dynamic_strings != NULL)))
10712     {
10713       unsigned char nb[16];
10714       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10715       bfd_vma buckets_vma;
10716
10717       if (fseek (file,
10718                  (archive_file_offset
10719                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10720                                      sizeof nb)),
10721                  SEEK_SET))
10722         {
10723           error (_("Unable to seek to start of dynamic information\n"));
10724           goto no_gnu_hash;
10725         }
10726
10727       if (fread (nb, 16, 1, file) != 1)
10728         {
10729           error (_("Failed to read in number of buckets\n"));
10730           goto no_gnu_hash;
10731         }
10732
10733       ngnubuckets = byte_get (nb, 4);
10734       gnusymidx = byte_get (nb + 4, 4);
10735       bitmaskwords = byte_get (nb + 8, 4);
10736       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10737       if (is_32bit_elf)
10738         buckets_vma += bitmaskwords * 4;
10739       else
10740         buckets_vma += bitmaskwords * 8;
10741
10742       if (fseek (file,
10743                  (archive_file_offset
10744                   + offset_from_vma (file, buckets_vma, 4)),
10745                  SEEK_SET))
10746         {
10747           error (_("Unable to seek to start of dynamic information\n"));
10748           goto no_gnu_hash;
10749         }
10750
10751       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10752
10753       if (gnubuckets == NULL)
10754         goto no_gnu_hash;
10755
10756       for (i = 0; i < ngnubuckets; i++)
10757         if (gnubuckets[i] != 0)
10758           {
10759             if (gnubuckets[i] < gnusymidx)
10760               return 0;
10761
10762             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10763               maxchain = gnubuckets[i];
10764           }
10765
10766       if (maxchain == 0xffffffff)
10767         goto no_gnu_hash;
10768
10769       maxchain -= gnusymidx;
10770
10771       if (fseek (file,
10772                  (archive_file_offset
10773                   + offset_from_vma (file, buckets_vma
10774                                            + 4 * (ngnubuckets + maxchain), 4)),
10775                  SEEK_SET))
10776         {
10777           error (_("Unable to seek to start of dynamic information\n"));
10778           goto no_gnu_hash;
10779         }
10780
10781       do
10782         {
10783           if (fread (nb, 4, 1, file) != 1)
10784             {
10785               error (_("Failed to determine last chain length\n"));
10786               goto no_gnu_hash;
10787             }
10788
10789           if (maxchain + 1 == 0)
10790             goto no_gnu_hash;
10791
10792           ++maxchain;
10793         }
10794       while ((byte_get (nb, 4) & 1) == 0);
10795
10796       if (fseek (file,
10797                  (archive_file_offset
10798                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10799                  SEEK_SET))
10800         {
10801           error (_("Unable to seek to start of dynamic information\n"));
10802           goto no_gnu_hash;
10803         }
10804
10805       gnuchains = get_dynamic_data (file, maxchain, 4);
10806       ngnuchains = maxchain;
10807
10808     no_gnu_hash:
10809       if (gnuchains == NULL)
10810         {
10811           free (gnubuckets);
10812           gnubuckets = NULL;
10813           ngnubuckets = 0;
10814           if (do_using_dynamic)
10815             return 0;
10816         }
10817     }
10818
10819   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10820       && do_syms
10821       && do_using_dynamic
10822       && dynamic_strings != NULL
10823       && dynamic_symbols != NULL)
10824     {
10825       unsigned long hn;
10826
10827       if (dynamic_info[DT_HASH])
10828         {
10829           bfd_vma si;
10830
10831           printf (_("\nSymbol table for image:\n"));
10832           if (is_32bit_elf)
10833             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10834           else
10835             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10836
10837           for (hn = 0; hn < nbuckets; hn++)
10838             {
10839               if (! buckets[hn])
10840                 continue;
10841
10842               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10843                 print_dynamic_symbol (si, hn);
10844             }
10845         }
10846
10847       if (dynamic_info_DT_GNU_HASH)
10848         {
10849           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10850           if (is_32bit_elf)
10851             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10852           else
10853             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10854
10855           for (hn = 0; hn < ngnubuckets; ++hn)
10856             if (gnubuckets[hn] != 0)
10857               {
10858                 bfd_vma si = gnubuckets[hn];
10859                 bfd_vma off = si - gnusymidx;
10860
10861                 do
10862                   {
10863                     print_dynamic_symbol (si, hn);
10864                     si++;
10865                   }
10866                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10867               }
10868         }
10869     }
10870   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10871            && section_headers != NULL)
10872     {
10873       unsigned int i;
10874
10875       for (i = 0, section = section_headers;
10876            i < elf_header.e_shnum;
10877            i++, section++)
10878         {
10879           unsigned int si;
10880           char * strtab = NULL;
10881           unsigned long int strtab_size = 0;
10882           Elf_Internal_Sym * symtab;
10883           Elf_Internal_Sym * psym;
10884           unsigned long num_syms;
10885
10886           if ((section->sh_type != SHT_SYMTAB
10887                && section->sh_type != SHT_DYNSYM)
10888               || (!do_syms
10889                   && section->sh_type == SHT_SYMTAB))
10890             continue;
10891
10892           if (section->sh_entsize == 0)
10893             {
10894               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10895                       printable_section_name (section));
10896               continue;
10897             }
10898
10899           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10900                   printable_section_name (section),
10901                   (unsigned long) (section->sh_size / section->sh_entsize));
10902
10903           if (is_32bit_elf)
10904             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10905           else
10906             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10907
10908           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10909           if (symtab == NULL)
10910             continue;
10911
10912           if (section->sh_link == elf_header.e_shstrndx)
10913             {
10914               strtab = string_table;
10915               strtab_size = string_table_length;
10916             }
10917           else if (section->sh_link < elf_header.e_shnum)
10918             {
10919               Elf_Internal_Shdr * string_sec;
10920
10921               string_sec = section_headers + section->sh_link;
10922
10923               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10924                                           1, string_sec->sh_size,
10925                                           _("string table"));
10926               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10927             }
10928
10929           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10930             {
10931               const char *version_string;
10932               enum versioned_symbol_info sym_info;
10933               unsigned short vna_other;
10934
10935               printf ("%6d: ", si);
10936               print_vma (psym->st_value, LONG_HEX);
10937               putchar (' ');
10938               print_vma (psym->st_size, DEC_5);
10939               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10940               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10941               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10942               /* Check to see if any other bits in the st_other field are set.
10943                  Note - displaying this information disrupts the layout of the
10944                  table being generated, but for the moment this case is very rare.  */
10945               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10946                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10947               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10948               print_symbol (25, psym->st_name < strtab_size
10949                             ? strtab + psym->st_name : _("<corrupt>"));
10950
10951               version_string
10952                 = get_symbol_version_string (file,
10953                                              section->sh_type == SHT_DYNSYM,
10954                                              strtab, strtab_size, si,
10955                                              psym, &sym_info, &vna_other);
10956               if (version_string)
10957                 {
10958                   if (sym_info == symbol_undefined)
10959                     printf ("@%s (%d)", version_string, vna_other);
10960                   else
10961                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10962                             version_string);
10963                 }
10964
10965               putchar ('\n');
10966             }
10967
10968           free (symtab);
10969           if (strtab != string_table)
10970             free (strtab);
10971         }
10972     }
10973   else if (do_syms)
10974     printf
10975       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10976
10977   if (do_histogram && buckets != NULL)
10978     {
10979       unsigned long * lengths;
10980       unsigned long * counts;
10981       unsigned long hn;
10982       bfd_vma si;
10983       unsigned long maxlength = 0;
10984       unsigned long nzero_counts = 0;
10985       unsigned long nsyms = 0;
10986       unsigned long chained;
10987
10988       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10989               (unsigned long) nbuckets);
10990
10991       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10992       if (lengths == NULL)
10993         {
10994           error (_("Out of memory allocating space for histogram buckets\n"));
10995           return 0;
10996         }
10997
10998       printf (_(" Length  Number     %% of total  Coverage\n"));
10999       for (hn = 0; hn < nbuckets; ++hn)
11000         {
11001           for (si = buckets[hn], chained = 0;
11002                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11003                si = chains[si], ++chained)
11004             {
11005               ++nsyms;
11006               if (maxlength < ++lengths[hn])
11007                 ++maxlength;
11008             }
11009
11010             /* PR binutils/17531: A corrupt binary could contain broken
11011                histogram data.  Do not go into an infinite loop trying
11012                to process it.  */
11013             if (chained > nchains)
11014               {
11015                 error (_("histogram chain is corrupt\n"));
11016                 break;
11017               }
11018         }
11019
11020       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11021       if (counts == NULL)
11022         {
11023           free (lengths);
11024           error (_("Out of memory allocating space for histogram counts\n"));
11025           return 0;
11026         }
11027
11028       for (hn = 0; hn < nbuckets; ++hn)
11029         ++counts[lengths[hn]];
11030
11031       if (nbuckets > 0)
11032         {
11033           unsigned long i;
11034           printf ("      0  %-10lu (%5.1f%%)\n",
11035                   counts[0], (counts[0] * 100.0) / nbuckets);
11036           for (i = 1; i <= maxlength; ++i)
11037             {
11038               nzero_counts += counts[i] * i;
11039               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11040                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11041                       (nzero_counts * 100.0) / nsyms);
11042             }
11043         }
11044
11045       free (counts);
11046       free (lengths);
11047     }
11048
11049   if (buckets != NULL)
11050     {
11051       free (buckets);
11052       free (chains);
11053     }
11054
11055   if (do_histogram && gnubuckets != NULL)
11056     {
11057       unsigned long * lengths;
11058       unsigned long * counts;
11059       unsigned long hn;
11060       unsigned long maxlength = 0;
11061       unsigned long nzero_counts = 0;
11062       unsigned long nsyms = 0;
11063
11064       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11065               (unsigned long) ngnubuckets);
11066
11067       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11068       if (lengths == NULL)
11069         {
11070           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11071           return 0;
11072         }
11073
11074       printf (_(" Length  Number     %% of total  Coverage\n"));
11075
11076       for (hn = 0; hn < ngnubuckets; ++hn)
11077         if (gnubuckets[hn] != 0)
11078           {
11079             bfd_vma off, length = 1;
11080
11081             for (off = gnubuckets[hn] - gnusymidx;
11082                  /* PR 17531 file: 010-77222-0.004.  */
11083                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11084                  ++off)
11085               ++length;
11086             lengths[hn] = length;
11087             if (length > maxlength)
11088               maxlength = length;
11089             nsyms += length;
11090           }
11091
11092       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11093       if (counts == NULL)
11094         {
11095           free (lengths);
11096           error (_("Out of memory allocating space for gnu histogram counts\n"));
11097           return 0;
11098         }
11099
11100       for (hn = 0; hn < ngnubuckets; ++hn)
11101         ++counts[lengths[hn]];
11102
11103       if (ngnubuckets > 0)
11104         {
11105           unsigned long j;
11106           printf ("      0  %-10lu (%5.1f%%)\n",
11107                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11108           for (j = 1; j <= maxlength; ++j)
11109             {
11110               nzero_counts += counts[j] * j;
11111               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11112                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11113                       (nzero_counts * 100.0) / nsyms);
11114             }
11115         }
11116
11117       free (counts);
11118       free (lengths);
11119       free (gnubuckets);
11120       free (gnuchains);
11121     }
11122
11123   return 1;
11124 }
11125
11126 static int
11127 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11128 {
11129   unsigned int i;
11130
11131   if (dynamic_syminfo == NULL
11132       || !do_dynamic)
11133     /* No syminfo, this is ok.  */
11134     return 1;
11135
11136   /* There better should be a dynamic symbol section.  */
11137   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11138     return 0;
11139
11140   if (dynamic_addr)
11141     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11142             dynamic_syminfo_offset, dynamic_syminfo_nent);
11143
11144   printf (_(" Num: Name                           BoundTo     Flags\n"));
11145   for (i = 0; i < dynamic_syminfo_nent; ++i)
11146     {
11147       unsigned short int flags = dynamic_syminfo[i].si_flags;
11148
11149       printf ("%4d: ", i);
11150       if (i >= num_dynamic_syms)
11151         printf (_("<corrupt index>"));
11152       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11153         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11154       else
11155         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11156       putchar (' ');
11157
11158       switch (dynamic_syminfo[i].si_boundto)
11159         {
11160         case SYMINFO_BT_SELF:
11161           fputs ("SELF       ", stdout);
11162           break;
11163         case SYMINFO_BT_PARENT:
11164           fputs ("PARENT     ", stdout);
11165           break;
11166         default:
11167           if (dynamic_syminfo[i].si_boundto > 0
11168               && dynamic_syminfo[i].si_boundto < dynamic_nent
11169               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11170             {
11171               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11172               putchar (' ' );
11173             }
11174           else
11175             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11176           break;
11177         }
11178
11179       if (flags & SYMINFO_FLG_DIRECT)
11180         printf (" DIRECT");
11181       if (flags & SYMINFO_FLG_PASSTHRU)
11182         printf (" PASSTHRU");
11183       if (flags & SYMINFO_FLG_COPY)
11184         printf (" COPY");
11185       if (flags & SYMINFO_FLG_LAZYLOAD)
11186         printf (" LAZYLOAD");
11187
11188       puts ("");
11189     }
11190
11191   return 1;
11192 }
11193
11194 /* Check to see if the given reloc needs to be handled in a target specific
11195    manner.  If so then process the reloc and return TRUE otherwise return
11196    FALSE.  */
11197
11198 static bfd_boolean
11199 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11200                                 unsigned char *     start,
11201                                 Elf_Internal_Sym *  symtab)
11202 {
11203   unsigned int reloc_type = get_reloc_type (reloc->r_info);
11204
11205   switch (elf_header.e_machine)
11206     {
11207     case EM_MSP430:
11208     case EM_MSP430_OLD:
11209       {
11210         static Elf_Internal_Sym * saved_sym = NULL;
11211
11212         switch (reloc_type)
11213           {
11214           case 10: /* R_MSP430_SYM_DIFF */
11215             if (uses_msp430x_relocs ())
11216               break;
11217           case 21: /* R_MSP430X_SYM_DIFF */
11218             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11219             return TRUE;
11220
11221           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11222           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11223             goto handle_sym_diff;
11224
11225           case 5: /* R_MSP430_16_BYTE */
11226           case 9: /* R_MSP430_8 */
11227             if (uses_msp430x_relocs ())
11228               break;
11229             goto handle_sym_diff;
11230
11231           case 2: /* R_MSP430_ABS16 */
11232           case 15: /* R_MSP430X_ABS16 */
11233             if (! uses_msp430x_relocs ())
11234               break;
11235             goto handle_sym_diff;
11236
11237           handle_sym_diff:
11238             if (saved_sym != NULL)
11239               {
11240                 bfd_vma value;
11241
11242                 value = reloc->r_addend
11243                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11244                      - saved_sym->st_value);
11245
11246                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11247
11248                 saved_sym = NULL;
11249                 return TRUE;
11250               }
11251             break;
11252
11253           default:
11254             if (saved_sym != NULL)
11255               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11256             break;
11257           }
11258         break;
11259       }
11260
11261     case EM_MN10300:
11262     case EM_CYGNUS_MN10300:
11263       {
11264         static Elf_Internal_Sym * saved_sym = NULL;
11265
11266         switch (reloc_type)
11267           {
11268           case 34: /* R_MN10300_ALIGN */
11269             return TRUE;
11270           case 33: /* R_MN10300_SYM_DIFF */
11271             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11272             return TRUE;
11273           case 1: /* R_MN10300_32 */
11274           case 2: /* R_MN10300_16 */
11275             if (saved_sym != NULL)
11276               {
11277                 bfd_vma value;
11278
11279                 value = reloc->r_addend
11280                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11281                      - saved_sym->st_value);
11282
11283                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11284
11285                 saved_sym = NULL;
11286                 return TRUE;
11287               }
11288             break;
11289           default:
11290             if (saved_sym != NULL)
11291               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11292             break;
11293           }
11294         break;
11295       }
11296
11297     case EM_RL78:
11298       {
11299         static bfd_vma saved_sym1 = 0;
11300         static bfd_vma saved_sym2 = 0;
11301         static bfd_vma value;
11302
11303         switch (reloc_type)
11304           {
11305           case 0x80: /* R_RL78_SYM.  */
11306             saved_sym1 = saved_sym2;
11307             saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11308             saved_sym2 += reloc->r_addend;
11309             return TRUE;
11310
11311           case 0x83: /* R_RL78_OPsub.  */
11312             value = saved_sym1 - saved_sym2;
11313             saved_sym2 = saved_sym1 = 0;
11314             return TRUE;
11315             break;
11316
11317           case 0x41: /* R_RL78_ABS32.  */
11318             byte_put (start + reloc->r_offset, value, 4);
11319             value = 0;
11320             return TRUE;
11321
11322           case 0x43: /* R_RL78_ABS16.  */
11323             byte_put (start + reloc->r_offset, value, 2);
11324             value = 0;
11325             return TRUE;
11326
11327           default:
11328             break;
11329           }
11330         break;
11331       }
11332     }
11333
11334   return FALSE;
11335 }
11336
11337 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11338    DWARF debug sections.  This is a target specific test.  Note - we do not
11339    go through the whole including-target-headers-multiple-times route, (as
11340    we have already done with <elf/h8.h>) because this would become very
11341    messy and even then this function would have to contain target specific
11342    information (the names of the relocs instead of their numeric values).
11343    FIXME: This is not the correct way to solve this problem.  The proper way
11344    is to have target specific reloc sizing and typing functions created by
11345    the reloc-macros.h header, in the same way that it already creates the
11346    reloc naming functions.  */
11347
11348 static bfd_boolean
11349 is_32bit_abs_reloc (unsigned int reloc_type)
11350 {
11351   switch (elf_header.e_machine)
11352     {
11353     case EM_386:
11354     case EM_IAMCU:
11355       return reloc_type == 1; /* R_386_32.  */
11356     case EM_68K:
11357       return reloc_type == 1; /* R_68K_32.  */
11358     case EM_860:
11359       return reloc_type == 1; /* R_860_32.  */
11360     case EM_960:
11361       return reloc_type == 2; /* R_960_32.  */
11362     case EM_AARCH64:
11363       return reloc_type == 258; /* R_AARCH64_ABS32 */
11364     case EM_ALPHA:
11365       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11366     case EM_ARC:
11367       return reloc_type == 1; /* R_ARC_32.  */
11368     case EM_ARC_COMPACT:
11369     case EM_ARC_COMPACT2:
11370       return reloc_type == 4; /* R_ARC_32.  */
11371     case EM_ARM:
11372       return reloc_type == 2; /* R_ARM_ABS32 */
11373     case EM_AVR_OLD:
11374     case EM_AVR:
11375       return reloc_type == 1;
11376     case EM_ADAPTEVA_EPIPHANY:
11377       return reloc_type == 3;
11378     case EM_BLACKFIN:
11379       return reloc_type == 0x12; /* R_byte4_data.  */
11380     case EM_CRIS:
11381       return reloc_type == 3; /* R_CRIS_32.  */
11382     case EM_CR16:
11383       return reloc_type == 3; /* R_CR16_NUM32.  */
11384     case EM_CRX:
11385       return reloc_type == 15; /* R_CRX_NUM32.  */
11386     case EM_CYGNUS_FRV:
11387       return reloc_type == 1;
11388     case EM_CYGNUS_D10V:
11389     case EM_D10V:
11390       return reloc_type == 6; /* R_D10V_32.  */
11391     case EM_CYGNUS_D30V:
11392     case EM_D30V:
11393       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11394     case EM_DLX:
11395       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11396     case EM_CYGNUS_FR30:
11397     case EM_FR30:
11398       return reloc_type == 3; /* R_FR30_32.  */
11399     case EM_FT32:
11400       return reloc_type == 1; /* R_FT32_32.  */
11401     case EM_H8S:
11402     case EM_H8_300:
11403     case EM_H8_300H:
11404       return reloc_type == 1; /* R_H8_DIR32.  */
11405     case EM_IA_64:
11406       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
11407         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
11408     case EM_IP2K_OLD:
11409     case EM_IP2K:
11410       return reloc_type == 2; /* R_IP2K_32.  */
11411     case EM_IQ2000:
11412       return reloc_type == 2; /* R_IQ2000_32.  */
11413     case EM_LATTICEMICO32:
11414       return reloc_type == 3; /* R_LM32_32.  */
11415     case EM_M32C_OLD:
11416     case EM_M32C:
11417       return reloc_type == 3; /* R_M32C_32.  */
11418     case EM_M32R:
11419       return reloc_type == 34; /* R_M32R_32_RELA.  */
11420     case EM_MCORE:
11421       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11422     case EM_CYGNUS_MEP:
11423       return reloc_type == 4; /* R_MEP_32.  */
11424     case EM_METAG:
11425       return reloc_type == 2; /* R_METAG_ADDR32.  */
11426     case EM_MICROBLAZE:
11427       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11428     case EM_MIPS:
11429       return reloc_type == 2; /* R_MIPS_32.  */
11430     case EM_MMIX:
11431       return reloc_type == 4; /* R_MMIX_32.  */
11432     case EM_CYGNUS_MN10200:
11433     case EM_MN10200:
11434       return reloc_type == 1; /* R_MN10200_32.  */
11435     case EM_CYGNUS_MN10300:
11436     case EM_MN10300:
11437       return reloc_type == 1; /* R_MN10300_32.  */
11438     case EM_MOXIE:
11439       return reloc_type == 1; /* R_MOXIE_32.  */
11440     case EM_MSP430_OLD:
11441     case EM_MSP430:
11442       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11443     case EM_MT:
11444       return reloc_type == 2; /* R_MT_32.  */
11445     case EM_NDS32:
11446       return reloc_type == 20; /* R_NDS32_RELA.  */
11447     case EM_ALTERA_NIOS2:
11448       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11449     case EM_NIOS32:
11450       return reloc_type == 1; /* R_NIOS_32.  */
11451     case EM_OR1K:
11452       return reloc_type == 1; /* R_OR1K_32.  */
11453     case EM_PARISC:
11454       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11455               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11456     case EM_PJ:
11457     case EM_PJ_OLD:
11458       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11459     case EM_PPC64:
11460       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11461     case EM_PPC:
11462       return reloc_type == 1; /* R_PPC_ADDR32.  */
11463     case EM_RL78:
11464       return reloc_type == 1; /* R_RL78_DIR32.  */
11465     case EM_RX:
11466       return reloc_type == 1; /* R_RX_DIR32.  */
11467     case EM_S370:
11468       return reloc_type == 1; /* R_I370_ADDR31.  */
11469     case EM_S390_OLD:
11470     case EM_S390:
11471       return reloc_type == 4; /* R_S390_32.  */
11472     case EM_SCORE:
11473       return reloc_type == 8; /* R_SCORE_ABS32.  */
11474     case EM_SH:
11475       return reloc_type == 1; /* R_SH_DIR32.  */
11476     case EM_SPARC32PLUS:
11477     case EM_SPARCV9:
11478     case EM_SPARC:
11479       return reloc_type == 3 /* R_SPARC_32.  */
11480         || reloc_type == 23; /* R_SPARC_UA32.  */
11481     case EM_SPU:
11482       return reloc_type == 6; /* R_SPU_ADDR32 */
11483     case EM_TI_C6000:
11484       return reloc_type == 1; /* R_C6000_ABS32.  */
11485     case EM_TILEGX:
11486       return reloc_type == 2; /* R_TILEGX_32.  */
11487     case EM_TILEPRO:
11488       return reloc_type == 1; /* R_TILEPRO_32.  */
11489     case EM_CYGNUS_V850:
11490     case EM_V850:
11491       return reloc_type == 6; /* R_V850_ABS32.  */
11492     case EM_V800:
11493       return reloc_type == 0x33; /* R_V810_WORD.  */
11494     case EM_VAX:
11495       return reloc_type == 1; /* R_VAX_32.  */
11496     case EM_VISIUM:
11497       return reloc_type == 3;  /* R_VISIUM_32. */
11498     case EM_X86_64:
11499     case EM_L1OM:
11500     case EM_K1OM:
11501       return reloc_type == 10; /* R_X86_64_32.  */
11502     case EM_XC16X:
11503     case EM_C166:
11504       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11505     case EM_XGATE:
11506       return reloc_type == 4; /* R_XGATE_32.  */
11507     case EM_XSTORMY16:
11508       return reloc_type == 1; /* R_XSTROMY16_32.  */
11509     case EM_XTENSA_OLD:
11510     case EM_XTENSA:
11511       return reloc_type == 1; /* R_XTENSA_32.  */
11512     default:
11513       {
11514         static unsigned int prev_warn = 0;
11515
11516         /* Avoid repeating the same warning multiple times.  */
11517         if (prev_warn != elf_header.e_machine)
11518           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11519                  elf_header.e_machine);
11520         prev_warn = elf_header.e_machine;
11521         return FALSE;
11522       }
11523     }
11524 }
11525
11526 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11527    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11528
11529 static bfd_boolean
11530 is_32bit_pcrel_reloc (unsigned int reloc_type)
11531 {
11532   switch (elf_header.e_machine)
11533     {
11534     case EM_386:
11535     case EM_IAMCU:
11536       return reloc_type == 2;  /* R_386_PC32.  */
11537     case EM_68K:
11538       return reloc_type == 4;  /* R_68K_PC32.  */
11539     case EM_AARCH64:
11540       return reloc_type == 261; /* R_AARCH64_PREL32 */
11541     case EM_ADAPTEVA_EPIPHANY:
11542       return reloc_type == 6;
11543     case EM_ALPHA:
11544       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11545     case EM_ARM:
11546       return reloc_type == 3;  /* R_ARM_REL32 */
11547     case EM_MICROBLAZE:
11548       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11549     case EM_OR1K:
11550       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11551     case EM_PARISC:
11552       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11553     case EM_PPC:
11554       return reloc_type == 26; /* R_PPC_REL32.  */
11555     case EM_PPC64:
11556       return reloc_type == 26; /* R_PPC64_REL32.  */
11557     case EM_S390_OLD:
11558     case EM_S390:
11559       return reloc_type == 5;  /* R_390_PC32.  */
11560     case EM_SH:
11561       return reloc_type == 2;  /* R_SH_REL32.  */
11562     case EM_SPARC32PLUS:
11563     case EM_SPARCV9:
11564     case EM_SPARC:
11565       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11566     case EM_SPU:
11567       return reloc_type == 13; /* R_SPU_REL32.  */
11568     case EM_TILEGX:
11569       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11570     case EM_TILEPRO:
11571       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11572     case EM_VISIUM:
11573       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11574     case EM_X86_64:
11575     case EM_L1OM:
11576     case EM_K1OM:
11577       return reloc_type == 2;  /* R_X86_64_PC32.  */
11578     case EM_XTENSA_OLD:
11579     case EM_XTENSA:
11580       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11581     default:
11582       /* Do not abort or issue an error message here.  Not all targets use
11583          pc-relative 32-bit relocs in their DWARF debug information and we
11584          have already tested for target coverage in is_32bit_abs_reloc.  A
11585          more helpful warning message will be generated by apply_relocations
11586          anyway, so just return.  */
11587       return FALSE;
11588     }
11589 }
11590
11591 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11592    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11593
11594 static bfd_boolean
11595 is_64bit_abs_reloc (unsigned int reloc_type)
11596 {
11597   switch (elf_header.e_machine)
11598     {
11599     case EM_AARCH64:
11600       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11601     case EM_ALPHA:
11602       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11603     case EM_IA_64:
11604       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11605     case EM_PARISC:
11606       return reloc_type == 80; /* R_PARISC_DIR64.  */
11607     case EM_PPC64:
11608       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11609     case EM_SPARC32PLUS:
11610     case EM_SPARCV9:
11611     case EM_SPARC:
11612       return reloc_type == 54; /* R_SPARC_UA64.  */
11613     case EM_X86_64:
11614     case EM_L1OM:
11615     case EM_K1OM:
11616       return reloc_type == 1; /* R_X86_64_64.  */
11617     case EM_S390_OLD:
11618     case EM_S390:
11619       return reloc_type == 22;  /* R_S390_64.  */
11620     case EM_TILEGX:
11621       return reloc_type == 1; /* R_TILEGX_64.  */
11622     case EM_MIPS:
11623       return reloc_type == 18;  /* R_MIPS_64.  */
11624     default:
11625       return FALSE;
11626     }
11627 }
11628
11629 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11630    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11631
11632 static bfd_boolean
11633 is_64bit_pcrel_reloc (unsigned int reloc_type)
11634 {
11635   switch (elf_header.e_machine)
11636     {
11637     case EM_AARCH64:
11638       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11639     case EM_ALPHA:
11640       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11641     case EM_IA_64:
11642       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11643     case EM_PARISC:
11644       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11645     case EM_PPC64:
11646       return reloc_type == 44; /* R_PPC64_REL64.  */
11647     case EM_SPARC32PLUS:
11648     case EM_SPARCV9:
11649     case EM_SPARC:
11650       return reloc_type == 46; /* R_SPARC_DISP64.  */
11651     case EM_X86_64:
11652     case EM_L1OM:
11653     case EM_K1OM:
11654       return reloc_type == 24; /* R_X86_64_PC64.  */
11655     case EM_S390_OLD:
11656     case EM_S390:
11657       return reloc_type == 23;  /* R_S390_PC64.  */
11658     case EM_TILEGX:
11659       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11660     default:
11661       return FALSE;
11662     }
11663 }
11664
11665 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11666    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11667
11668 static bfd_boolean
11669 is_24bit_abs_reloc (unsigned int reloc_type)
11670 {
11671   switch (elf_header.e_machine)
11672     {
11673     case EM_CYGNUS_MN10200:
11674     case EM_MN10200:
11675       return reloc_type == 4; /* R_MN10200_24.  */
11676     default:
11677       return FALSE;
11678     }
11679 }
11680
11681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11682    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11683
11684 static bfd_boolean
11685 is_16bit_abs_reloc (unsigned int reloc_type)
11686 {
11687   switch (elf_header.e_machine)
11688     {
11689     case EM_ARC:
11690     case EM_ARC_COMPACT:
11691     case EM_ARC_COMPACT2:
11692       return reloc_type == 2; /* R_ARC_16.  */
11693     case EM_AVR_OLD:
11694     case EM_AVR:
11695       return reloc_type == 4; /* R_AVR_16.  */
11696     case EM_ADAPTEVA_EPIPHANY:
11697       return reloc_type == 5;
11698     case EM_CYGNUS_D10V:
11699     case EM_D10V:
11700       return reloc_type == 3; /* R_D10V_16.  */
11701     case EM_H8S:
11702     case EM_H8_300:
11703     case EM_H8_300H:
11704       return reloc_type == R_H8_DIR16;
11705     case EM_IP2K_OLD:
11706     case EM_IP2K:
11707       return reloc_type == 1; /* R_IP2K_16.  */
11708     case EM_M32C_OLD:
11709     case EM_M32C:
11710       return reloc_type == 1; /* R_M32C_16 */
11711     case EM_MSP430:
11712       if (uses_msp430x_relocs ())
11713         return reloc_type == 2; /* R_MSP430_ABS16.  */
11714     case EM_MSP430_OLD:
11715       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11716     case EM_NDS32:
11717       return reloc_type == 19; /* R_NDS32_RELA.  */
11718     case EM_ALTERA_NIOS2:
11719       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11720     case EM_NIOS32:
11721       return reloc_type == 9; /* R_NIOS_16.  */
11722     case EM_OR1K:
11723       return reloc_type == 2; /* R_OR1K_16.  */
11724     case EM_TI_C6000:
11725       return reloc_type == 2; /* R_C6000_ABS16.  */
11726     case EM_XC16X:
11727     case EM_C166:
11728       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11729     case EM_CYGNUS_MN10200:
11730     case EM_MN10200:
11731       return reloc_type == 2; /* R_MN10200_16.  */
11732     case EM_CYGNUS_MN10300:
11733     case EM_MN10300:
11734       return reloc_type == 2; /* R_MN10300_16.  */
11735     case EM_VISIUM:
11736       return reloc_type == 2; /* R_VISIUM_16. */
11737     case EM_XGATE:
11738       return reloc_type == 3; /* R_XGATE_16.  */
11739     default:
11740       return FALSE;
11741     }
11742 }
11743
11744 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11745    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11746
11747 static bfd_boolean
11748 is_none_reloc (unsigned int reloc_type)
11749 {
11750   switch (elf_header.e_machine)
11751     {
11752     case EM_68K:     /* R_68K_NONE.  */
11753     case EM_386:     /* R_386_NONE.  */
11754     case EM_SPARC32PLUS:
11755     case EM_SPARCV9:
11756     case EM_SPARC:   /* R_SPARC_NONE.  */
11757     case EM_MIPS:    /* R_MIPS_NONE.  */
11758     case EM_PARISC:  /* R_PARISC_NONE.  */
11759     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11760     case EM_ADAPTEVA_EPIPHANY:
11761     case EM_PPC:     /* R_PPC_NONE.  */
11762     case EM_PPC64:   /* R_PPC64_NONE.  */
11763     case EM_ARC:     /* R_ARC_NONE.  */
11764     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
11765     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
11766     case EM_ARM:     /* R_ARM_NONE.  */
11767     case EM_IA_64:   /* R_IA64_NONE.  */
11768     case EM_SH:      /* R_SH_NONE.  */
11769     case EM_S390_OLD:
11770     case EM_S390:    /* R_390_NONE.  */
11771     case EM_CRIS:    /* R_CRIS_NONE.  */
11772     case EM_X86_64:  /* R_X86_64_NONE.  */
11773     case EM_L1OM:    /* R_X86_64_NONE.  */
11774     case EM_K1OM:    /* R_X86_64_NONE.  */
11775     case EM_MN10300: /* R_MN10300_NONE.  */
11776     case EM_FT32:    /* R_FT32_NONE.  */
11777     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11778     case EM_M32R:    /* R_M32R_NONE.  */
11779     case EM_TI_C6000:/* R_C6000_NONE.  */
11780     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11781     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11782     case EM_XC16X:
11783     case EM_C166:    /* R_XC16X_NONE.  */
11784     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11785     case EM_NIOS32:  /* R_NIOS_NONE.  */
11786     case EM_OR1K:    /* R_OR1K_NONE. */
11787       return reloc_type == 0;
11788     case EM_AARCH64:
11789       return reloc_type == 0 || reloc_type == 256;
11790     case EM_NDS32:
11791       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11792               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11793               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11794               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11795               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11796     case EM_XTENSA_OLD:
11797     case EM_XTENSA:
11798       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11799               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11800               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11801               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11802     case EM_METAG:
11803       return reloc_type == 3; /* R_METAG_NONE.  */
11804     }
11805   return FALSE;
11806 }
11807
11808 /* Returns TRUE if there is a relocation against
11809    section NAME at OFFSET bytes.  */
11810
11811 bfd_boolean
11812 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11813 {
11814   Elf_Internal_Rela * relocs;
11815   Elf_Internal_Rela * rp;
11816
11817   if (dsec == NULL || dsec->reloc_info == NULL)
11818     return FALSE;
11819
11820   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11821
11822   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11823     if (rp->r_offset == offset)
11824       return TRUE;
11825
11826    return FALSE;
11827 }
11828
11829 /* Apply relocations to a section.
11830    Note: So far support has been added only for those relocations
11831    which can be found in debug sections.
11832    If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11833    loaded relocs.  It is then the caller's responsibility to free them.
11834    FIXME: Add support for more relocations ?  */
11835
11836 static void
11837 apply_relocations (void *                     file,
11838                    const Elf_Internal_Shdr *  section,
11839                    unsigned char *            start,
11840                    bfd_size_type              size,
11841                    void **                     relocs_return,
11842                    unsigned long *            num_relocs_return)
11843 {
11844   Elf_Internal_Shdr * relsec;
11845   unsigned char * end = start + size;
11846
11847   if (relocs_return != NULL)
11848     {
11849       * (Elf_Internal_Rela **) relocs_return = NULL;
11850       * num_relocs_return = 0;
11851     }
11852
11853   if (elf_header.e_type != ET_REL)
11854     return;
11855
11856   /* Find the reloc section associated with the section.  */
11857   for (relsec = section_headers;
11858        relsec < section_headers + elf_header.e_shnum;
11859        ++relsec)
11860     {
11861       bfd_boolean is_rela;
11862       unsigned long num_relocs;
11863       Elf_Internal_Rela * relocs;
11864       Elf_Internal_Rela * rp;
11865       Elf_Internal_Shdr * symsec;
11866       Elf_Internal_Sym * symtab;
11867       unsigned long num_syms;
11868       Elf_Internal_Sym * sym;
11869
11870       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11871           || relsec->sh_info >= elf_header.e_shnum
11872           || section_headers + relsec->sh_info != section
11873           || relsec->sh_size == 0
11874           || relsec->sh_link >= elf_header.e_shnum)
11875         continue;
11876
11877       is_rela = relsec->sh_type == SHT_RELA;
11878
11879       if (is_rela)
11880         {
11881           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11882                                   relsec->sh_size, & relocs, & num_relocs))
11883             return;
11884         }
11885       else
11886         {
11887           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11888                                  relsec->sh_size, & relocs, & num_relocs))
11889             return;
11890         }
11891
11892       /* SH uses RELA but uses in place value instead of the addend field.  */
11893       if (elf_header.e_machine == EM_SH)
11894         is_rela = FALSE;
11895
11896       symsec = section_headers + relsec->sh_link;
11897       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11898
11899       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11900         {
11901           bfd_vma         addend;
11902           unsigned int    reloc_type;
11903           unsigned int    reloc_size;
11904           unsigned char * rloc;
11905           unsigned long   sym_index;
11906
11907           reloc_type = get_reloc_type (rp->r_info);
11908
11909           if (target_specific_reloc_handling (rp, start, symtab))
11910             continue;
11911           else if (is_none_reloc (reloc_type))
11912             continue;
11913           else if (is_32bit_abs_reloc (reloc_type)
11914                    || is_32bit_pcrel_reloc (reloc_type))
11915             reloc_size = 4;
11916           else if (is_64bit_abs_reloc (reloc_type)
11917                    || is_64bit_pcrel_reloc (reloc_type))
11918             reloc_size = 8;
11919           else if (is_24bit_abs_reloc (reloc_type))
11920             reloc_size = 3;
11921           else if (is_16bit_abs_reloc (reloc_type))
11922             reloc_size = 2;
11923           else
11924             {
11925               static unsigned int prev_reloc = 0;
11926               if (reloc_type != prev_reloc)
11927                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11928                       reloc_type, printable_section_name (section));
11929               prev_reloc = reloc_type;
11930               continue;
11931             }
11932
11933           rloc = start + rp->r_offset;
11934           if ((rloc + reloc_size) > end || (rloc < start))
11935             {
11936               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11937                     (unsigned long) rp->r_offset,
11938                     printable_section_name (section));
11939               continue;
11940             }
11941
11942           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11943           if (sym_index >= num_syms)
11944             {
11945               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11946                     sym_index, printable_section_name (section));
11947               continue;
11948             }
11949           sym = symtab + sym_index;
11950
11951           /* If the reloc has a symbol associated with it,
11952              make sure that it is of an appropriate type.
11953
11954              Relocations against symbols without type can happen.
11955              Gcc -feliminate-dwarf2-dups may generate symbols
11956              without type for debug info.
11957
11958              Icc generates relocations against function symbols
11959              instead of local labels.
11960
11961              Relocations against object symbols can happen, eg when
11962              referencing a global array.  For an example of this see
11963              the _clz.o binary in libgcc.a.  */
11964           if (sym != symtab
11965               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11966             {
11967               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11968                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11969                     (long int)(rp - relocs),
11970                     printable_section_name (relsec));
11971               continue;
11972             }
11973
11974           addend = 0;
11975           if (is_rela)
11976             addend += rp->r_addend;
11977           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11978              partial_inplace.  */
11979           if (!is_rela
11980               || (elf_header.e_machine == EM_XTENSA
11981                   && reloc_type == 1)
11982               || ((elf_header.e_machine == EM_PJ
11983                    || elf_header.e_machine == EM_PJ_OLD)
11984                   && reloc_type == 1)
11985               || ((elf_header.e_machine == EM_D30V
11986                    || elf_header.e_machine == EM_CYGNUS_D30V)
11987                   && reloc_type == 12))
11988             addend += byte_get (rloc, reloc_size);
11989
11990           if (is_32bit_pcrel_reloc (reloc_type)
11991               || is_64bit_pcrel_reloc (reloc_type))
11992             {
11993               /* On HPPA, all pc-relative relocations are biased by 8.  */
11994               if (elf_header.e_machine == EM_PARISC)
11995                 addend -= 8;
11996               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11997                         reloc_size);
11998             }
11999           else
12000             byte_put (rloc, addend + sym->st_value, reloc_size);
12001         }
12002
12003       free (symtab);
12004
12005       if (relocs_return)
12006         {
12007           * (Elf_Internal_Rela **) relocs_return = relocs;
12008           * num_relocs_return = num_relocs;
12009         }
12010       else
12011         free (relocs);
12012
12013       break;
12014     }
12015 }
12016
12017 #ifdef SUPPORT_DISASSEMBLY
12018 static int
12019 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12020 {
12021   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12022
12023   /* FIXME: XXX -- to be done --- XXX */
12024
12025   return 1;
12026 }
12027 #endif
12028
12029 /* Reads in the contents of SECTION from FILE, returning a pointer
12030    to a malloc'ed buffer or NULL if something went wrong.  */
12031
12032 static char *
12033 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12034 {
12035   bfd_size_type num_bytes;
12036
12037   num_bytes = section->sh_size;
12038
12039   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12040     {
12041       printf (_("\nSection '%s' has no data to dump.\n"),
12042               printable_section_name (section));
12043       return NULL;
12044     }
12045
12046   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12047                              _("section contents"));
12048 }
12049
12050 /* Uncompresses a section that was compressed using zlib, in place.  */
12051
12052 static bfd_boolean
12053 uncompress_section_contents (unsigned char **buffer,
12054                              dwarf_size_type uncompressed_size,
12055                              dwarf_size_type *size)
12056 {
12057   dwarf_size_type compressed_size = *size;
12058   unsigned char * compressed_buffer = *buffer;
12059   unsigned char * uncompressed_buffer;
12060   z_stream strm;
12061   int rc;
12062
12063   /* It is possible the section consists of several compressed
12064      buffers concatenated together, so we uncompress in a loop.  */
12065   /* PR 18313: The state field in the z_stream structure is supposed
12066      to be invisible to the user (ie us), but some compilers will
12067      still complain about it being used without initialisation.  So
12068      we first zero the entire z_stream structure and then set the fields
12069      that we need.  */
12070   memset (& strm, 0, sizeof strm);
12071   strm.avail_in = compressed_size;
12072   strm.next_in = (Bytef *) compressed_buffer;
12073   strm.avail_out = uncompressed_size;
12074   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12075
12076   rc = inflateInit (& strm);
12077   while (strm.avail_in > 0)
12078     {
12079       if (rc != Z_OK)
12080         goto fail;
12081       strm.next_out = ((Bytef *) uncompressed_buffer
12082                        + (uncompressed_size - strm.avail_out));
12083       rc = inflate (&strm, Z_FINISH);
12084       if (rc != Z_STREAM_END)
12085         goto fail;
12086       rc = inflateReset (& strm);
12087     }
12088   rc = inflateEnd (& strm);
12089   if (rc != Z_OK
12090       || strm.avail_out != 0)
12091     goto fail;
12092
12093   *buffer = uncompressed_buffer;
12094   *size = uncompressed_size;
12095   return TRUE;
12096
12097  fail:
12098   free (uncompressed_buffer);
12099   /* Indicate decompression failure.  */
12100   *buffer = NULL;
12101   return FALSE;
12102 }
12103
12104 static void
12105 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12106 {
12107   Elf_Internal_Shdr *  relsec;
12108   bfd_size_type        num_bytes;
12109   unsigned char *      data;
12110   unsigned char *      end;
12111   unsigned char *      real_start;
12112   unsigned char *      start;
12113   bfd_boolean          some_strings_shown;
12114
12115   real_start = start = (unsigned char *) get_section_contents (section,
12116                                                                file);
12117   if (start == NULL)
12118     return;
12119   num_bytes = section->sh_size;
12120
12121   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12122
12123   if (decompress_dumps)
12124     {
12125       dwarf_size_type new_size = num_bytes;
12126       dwarf_size_type uncompressed_size = 0;
12127
12128       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12129         {
12130           Elf_Internal_Chdr chdr;
12131           unsigned int compression_header_size
12132             = get_compression_header (& chdr, (unsigned char *) start);
12133
12134           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12135             {
12136               warn (_("section '%s' has unsupported compress type: %d\n"),
12137                     printable_section_name (section), chdr.ch_type);
12138               return;
12139             }
12140           else if (chdr.ch_addralign != section->sh_addralign)
12141             {
12142               warn (_("compressed section '%s' is corrupted\n"),
12143                     printable_section_name (section));
12144               return;
12145             }
12146           uncompressed_size = chdr.ch_size;
12147           start += compression_header_size;
12148           new_size -= compression_header_size;
12149         }
12150       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12151         {
12152           /* Read the zlib header.  In this case, it should be "ZLIB"
12153              followed by the uncompressed section size, 8 bytes in
12154              big-endian order.  */
12155           uncompressed_size = start[4]; uncompressed_size <<= 8;
12156           uncompressed_size += start[5]; uncompressed_size <<= 8;
12157           uncompressed_size += start[6]; uncompressed_size <<= 8;
12158           uncompressed_size += start[7]; uncompressed_size <<= 8;
12159           uncompressed_size += start[8]; uncompressed_size <<= 8;
12160           uncompressed_size += start[9]; uncompressed_size <<= 8;
12161           uncompressed_size += start[10]; uncompressed_size <<= 8;
12162           uncompressed_size += start[11];
12163           start += 12;
12164           new_size -= 12;
12165         }
12166
12167       if (uncompressed_size
12168           && uncompress_section_contents (& start,
12169                                           uncompressed_size, & new_size))
12170         num_bytes = new_size;
12171     }
12172
12173   /* If the section being dumped has relocations against it the user might
12174      be expecting these relocations to have been applied.  Check for this
12175      case and issue a warning message in order to avoid confusion.
12176      FIXME: Maybe we ought to have an option that dumps a section with
12177      relocs applied ?  */
12178   for (relsec = section_headers;
12179        relsec < section_headers + elf_header.e_shnum;
12180        ++relsec)
12181     {
12182       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12183           || relsec->sh_info >= elf_header.e_shnum
12184           || section_headers + relsec->sh_info != section
12185           || relsec->sh_size == 0
12186           || relsec->sh_link >= elf_header.e_shnum)
12187         continue;
12188
12189       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12190       break;
12191     }
12192
12193   data = start;
12194   end  = start + num_bytes;
12195   some_strings_shown = FALSE;
12196
12197   while (data < end)
12198     {
12199       while (!ISPRINT (* data))
12200         if (++ data >= end)
12201           break;
12202
12203       if (data < end)
12204         {
12205           size_t maxlen = end - data;
12206
12207 #ifndef __MSVCRT__
12208           /* PR 11128: Use two separate invocations in order to work
12209              around bugs in the Solaris 8 implementation of printf.  */
12210           printf ("  [%6tx]  ", data - start);
12211 #else
12212           printf ("  [%6Ix]  ", (size_t) (data - start));
12213 #endif
12214           if (maxlen > 0)
12215             {
12216               print_symbol ((int) maxlen, (const char *) data);
12217               putchar ('\n');
12218               data += strnlen ((const char *) data, maxlen);
12219             }
12220           else
12221             {
12222               printf (_("<corrupt>\n"));
12223               data = end;
12224             }
12225           some_strings_shown = TRUE;
12226         }
12227     }
12228
12229   if (! some_strings_shown)
12230     printf (_("  No strings found in this section."));
12231
12232   free (real_start);
12233
12234   putchar ('\n');
12235 }
12236
12237 static void
12238 dump_section_as_bytes (Elf_Internal_Shdr * section,
12239                        FILE * file,
12240                        bfd_boolean relocate)
12241 {
12242   Elf_Internal_Shdr * relsec;
12243   bfd_size_type       bytes;
12244   bfd_size_type       section_size;
12245   bfd_vma             addr;
12246   unsigned char *     data;
12247   unsigned char *     real_start;
12248   unsigned char *     start;
12249
12250   real_start = start = (unsigned char *) get_section_contents (section, file);
12251   if (start == NULL)
12252     return;
12253   section_size = section->sh_size;
12254
12255   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12256
12257   if (decompress_dumps)
12258     {
12259       dwarf_size_type new_size = section_size;
12260       dwarf_size_type uncompressed_size = 0;
12261
12262       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12263         {
12264           Elf_Internal_Chdr chdr;
12265           unsigned int compression_header_size
12266             = get_compression_header (& chdr, start);
12267
12268           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12269             {
12270               warn (_("section '%s' has unsupported compress type: %d\n"),
12271                     printable_section_name (section), chdr.ch_type);
12272               return;
12273             }
12274           else if (chdr.ch_addralign != section->sh_addralign)
12275             {
12276               warn (_("compressed section '%s' is corrupted\n"),
12277                     printable_section_name (section));
12278               return;
12279             }
12280           uncompressed_size = chdr.ch_size;
12281           start += compression_header_size;
12282           new_size -= compression_header_size;
12283         }
12284       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12285         {
12286           /* Read the zlib header.  In this case, it should be "ZLIB"
12287              followed by the uncompressed section size, 8 bytes in
12288              big-endian order.  */
12289           uncompressed_size = start[4]; uncompressed_size <<= 8;
12290           uncompressed_size += start[5]; uncompressed_size <<= 8;
12291           uncompressed_size += start[6]; uncompressed_size <<= 8;
12292           uncompressed_size += start[7]; uncompressed_size <<= 8;
12293           uncompressed_size += start[8]; uncompressed_size <<= 8;
12294           uncompressed_size += start[9]; uncompressed_size <<= 8;
12295           uncompressed_size += start[10]; uncompressed_size <<= 8;
12296           uncompressed_size += start[11];
12297           start += 12;
12298           new_size -= 12;
12299         }
12300
12301       if (uncompressed_size
12302           && uncompress_section_contents (& start, uncompressed_size,
12303                                           & new_size))
12304         section_size = new_size;
12305     }
12306
12307   if (relocate)
12308     {
12309       apply_relocations (file, section, start, section_size, NULL, NULL);
12310     }
12311   else
12312     {
12313       /* If the section being dumped has relocations against it the user might
12314          be expecting these relocations to have been applied.  Check for this
12315          case and issue a warning message in order to avoid confusion.
12316          FIXME: Maybe we ought to have an option that dumps a section with
12317          relocs applied ?  */
12318       for (relsec = section_headers;
12319            relsec < section_headers + elf_header.e_shnum;
12320            ++relsec)
12321         {
12322           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12323               || relsec->sh_info >= elf_header.e_shnum
12324               || section_headers + relsec->sh_info != section
12325               || relsec->sh_size == 0
12326               || relsec->sh_link >= elf_header.e_shnum)
12327             continue;
12328
12329           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12330           break;
12331         }
12332     }
12333
12334   addr = section->sh_addr;
12335   bytes = section_size;
12336   data = start;
12337
12338   while (bytes)
12339     {
12340       int j;
12341       int k;
12342       int lbytes;
12343
12344       lbytes = (bytes > 16 ? 16 : bytes);
12345
12346       printf ("  0x%8.8lx ", (unsigned long) addr);
12347
12348       for (j = 0; j < 16; j++)
12349         {
12350           if (j < lbytes)
12351             printf ("%2.2x", data[j]);
12352           else
12353             printf ("  ");
12354
12355           if ((j & 3) == 3)
12356             printf (" ");
12357         }
12358
12359       for (j = 0; j < lbytes; j++)
12360         {
12361           k = data[j];
12362           if (k >= ' ' && k < 0x7f)
12363             printf ("%c", k);
12364           else
12365             printf (".");
12366         }
12367
12368       putchar ('\n');
12369
12370       data  += lbytes;
12371       addr  += lbytes;
12372       bytes -= lbytes;
12373     }
12374
12375   free (real_start);
12376
12377   putchar ('\n');
12378 }
12379
12380 static int
12381 load_specific_debug_section (enum dwarf_section_display_enum debug,
12382                              const Elf_Internal_Shdr * sec, void * file)
12383 {
12384   struct dwarf_section * section = &debug_displays [debug].section;
12385   char buf [64];
12386
12387   /* If it is already loaded, do nothing.  */
12388   if (section->start != NULL)
12389     return 1;
12390
12391   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12392   section->address = sec->sh_addr;
12393   section->user_data = NULL;
12394   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12395                                                sec->sh_offset, 1,
12396                                                sec->sh_size, buf);
12397   if (section->start == NULL)
12398     section->size = 0;
12399   else
12400     {
12401       unsigned char *start = section->start;
12402       dwarf_size_type size = sec->sh_size;
12403       dwarf_size_type uncompressed_size = 0;
12404
12405       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12406         {
12407           Elf_Internal_Chdr chdr;
12408           unsigned int compression_header_size
12409             = get_compression_header (&chdr, start);
12410           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12411             {
12412               warn (_("section '%s' has unsupported compress type: %d\n"),
12413                     section->name, chdr.ch_type);
12414               return 0;
12415             }
12416           else if (chdr.ch_addralign != sec->sh_addralign)
12417             {
12418               warn (_("compressed section '%s' is corrupted\n"),
12419                     section->name);
12420               return 0;
12421             }
12422           uncompressed_size = chdr.ch_size;
12423           start += compression_header_size;
12424           size -= compression_header_size;
12425         }
12426       else if (size > 12 && streq ((char *) start, "ZLIB"))
12427         {
12428           /* Read the zlib header.  In this case, it should be "ZLIB"
12429              followed by the uncompressed section size, 8 bytes in
12430              big-endian order.  */
12431           uncompressed_size = start[4]; uncompressed_size <<= 8;
12432           uncompressed_size += start[5]; uncompressed_size <<= 8;
12433           uncompressed_size += start[6]; uncompressed_size <<= 8;
12434           uncompressed_size += start[7]; uncompressed_size <<= 8;
12435           uncompressed_size += start[8]; uncompressed_size <<= 8;
12436           uncompressed_size += start[9]; uncompressed_size <<= 8;
12437           uncompressed_size += start[10]; uncompressed_size <<= 8;
12438           uncompressed_size += start[11];
12439           start += 12;
12440           size -= 12;
12441         }
12442
12443       if (uncompressed_size
12444           && uncompress_section_contents (&start, uncompressed_size,
12445                                           &size))
12446         {
12447           /* Free the compressed buffer, update the section buffer
12448              and the section size if uncompress is successful.  */
12449           free (section->start);
12450           section->start = start;
12451         }
12452       section->size = size;
12453     }
12454
12455   if (section->start == NULL)
12456     return 0;
12457
12458   if (debug_displays [debug].relocate)
12459     apply_relocations ((FILE *) file, sec, section->start, section->size,
12460                        & section->reloc_info, & section->num_relocs);
12461   else
12462     {
12463       section->reloc_info = NULL;
12464       section->num_relocs = 0;
12465     }
12466
12467   return 1;
12468 }
12469
12470 /* If this is not NULL, load_debug_section will only look for sections
12471    within the list of sections given here.  */
12472 unsigned int *section_subset = NULL;
12473
12474 int
12475 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12476 {
12477   struct dwarf_section * section = &debug_displays [debug].section;
12478   Elf_Internal_Shdr * sec;
12479
12480   /* Locate the debug section.  */
12481   sec = find_section_in_set (section->uncompressed_name, section_subset);
12482   if (sec != NULL)
12483     section->name = section->uncompressed_name;
12484   else
12485     {
12486       sec = find_section_in_set (section->compressed_name, section_subset);
12487       if (sec != NULL)
12488         section->name = section->compressed_name;
12489     }
12490   if (sec == NULL)
12491     return 0;
12492
12493   /* If we're loading from a subset of sections, and we've loaded
12494      a section matching this name before, it's likely that it's a
12495      different one.  */
12496   if (section_subset != NULL)
12497     free_debug_section (debug);
12498
12499   return load_specific_debug_section (debug, sec, (FILE *) file);
12500 }
12501
12502 void
12503 free_debug_section (enum dwarf_section_display_enum debug)
12504 {
12505   struct dwarf_section * section = &debug_displays [debug].section;
12506
12507   if (section->start == NULL)
12508     return;
12509
12510   free ((char *) section->start);
12511   section->start = NULL;
12512   section->address = 0;
12513   section->size = 0;
12514 }
12515
12516 static int
12517 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12518 {
12519   char * name = SECTION_NAME (section);
12520   const char * print_name = printable_section_name (section);
12521   bfd_size_type length;
12522   int result = 1;
12523   int i;
12524
12525   length = section->sh_size;
12526   if (length == 0)
12527     {
12528       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12529       return 0;
12530     }
12531   if (section->sh_type == SHT_NOBITS)
12532     {
12533       /* There is no point in dumping the contents of a debugging section
12534          which has the NOBITS type - the bits in the file will be random.
12535          This can happen when a file containing a .eh_frame section is
12536          stripped with the --only-keep-debug command line option.  */
12537       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12538               print_name);
12539       return 0;
12540     }
12541
12542   if (const_strneq (name, ".gnu.linkonce.wi."))
12543     name = ".debug_info";
12544
12545   /* See if we know how to display the contents of this section.  */
12546   for (i = 0; i < max; i++)
12547     if (streq (debug_displays[i].section.uncompressed_name, name)
12548         || (i == line && const_strneq (name, ".debug_line."))
12549         || streq (debug_displays[i].section.compressed_name, name))
12550       {
12551         struct dwarf_section * sec = &debug_displays [i].section;
12552         int secondary = (section != find_section (name));
12553
12554         if (secondary)
12555           free_debug_section ((enum dwarf_section_display_enum) i);
12556
12557         if (i == line && const_strneq (name, ".debug_line."))
12558           sec->name = name;
12559         else if (streq (sec->uncompressed_name, name))
12560           sec->name = sec->uncompressed_name;
12561         else
12562           sec->name = sec->compressed_name;
12563         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12564                                          section, file))
12565           {
12566             /* If this debug section is part of a CU/TU set in a .dwp file,
12567                restrict load_debug_section to the sections in that set.  */
12568             section_subset = find_cu_tu_set (file, shndx);
12569
12570             result &= debug_displays[i].display (sec, file);
12571
12572             section_subset = NULL;
12573
12574             if (secondary || (i != info && i != abbrev))
12575               free_debug_section ((enum dwarf_section_display_enum) i);
12576           }
12577
12578         break;
12579       }
12580
12581   if (i == max)
12582     {
12583       printf (_("Unrecognized debug section: %s\n"), print_name);
12584       result = 0;
12585     }
12586
12587   return result;
12588 }
12589
12590 /* Set DUMP_SECTS for all sections where dumps were requested
12591    based on section name.  */
12592
12593 static void
12594 initialise_dumps_byname (void)
12595 {
12596   struct dump_list_entry * cur;
12597
12598   for (cur = dump_sects_byname; cur; cur = cur->next)
12599     {
12600       unsigned int i;
12601       int any;
12602
12603       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12604         if (streq (SECTION_NAME (section_headers + i), cur->name))
12605           {
12606             request_dump_bynumber (i, cur->type);
12607             any = 1;
12608           }
12609
12610       if (!any)
12611         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12612               cur->name);
12613     }
12614 }
12615
12616 static void
12617 process_section_contents (FILE * file)
12618 {
12619   Elf_Internal_Shdr * section;
12620   unsigned int i;
12621
12622   if (! do_dump)
12623     return;
12624
12625   initialise_dumps_byname ();
12626
12627   for (i = 0, section = section_headers;
12628        i < elf_header.e_shnum && i < num_dump_sects;
12629        i++, section++)
12630     {
12631 #ifdef SUPPORT_DISASSEMBLY
12632       if (dump_sects[i] & DISASS_DUMP)
12633         disassemble_section (section, file);
12634 #endif
12635       if (dump_sects[i] & HEX_DUMP)
12636         dump_section_as_bytes (section, file, FALSE);
12637
12638       if (dump_sects[i] & RELOC_DUMP)
12639         dump_section_as_bytes (section, file, TRUE);
12640
12641       if (dump_sects[i] & STRING_DUMP)
12642         dump_section_as_strings (section, file);
12643
12644       if (dump_sects[i] & DEBUG_DUMP)
12645         display_debug_section (i, section, file);
12646     }
12647
12648   /* Check to see if the user requested a
12649      dump of a section that does not exist.  */
12650   while (i++ < num_dump_sects)
12651     if (dump_sects[i])
12652       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12653 }
12654
12655 static void
12656 process_mips_fpe_exception (int mask)
12657 {
12658   if (mask)
12659     {
12660       int first = 1;
12661       if (mask & OEX_FPU_INEX)
12662         fputs ("INEX", stdout), first = 0;
12663       if (mask & OEX_FPU_UFLO)
12664         printf ("%sUFLO", first ? "" : "|"), first = 0;
12665       if (mask & OEX_FPU_OFLO)
12666         printf ("%sOFLO", first ? "" : "|"), first = 0;
12667       if (mask & OEX_FPU_DIV0)
12668         printf ("%sDIV0", first ? "" : "|"), first = 0;
12669       if (mask & OEX_FPU_INVAL)
12670         printf ("%sINVAL", first ? "" : "|");
12671     }
12672   else
12673     fputs ("0", stdout);
12674 }
12675
12676 /* Display's the value of TAG at location P.  If TAG is
12677    greater than 0 it is assumed to be an unknown tag, and
12678    a message is printed to this effect.  Otherwise it is
12679    assumed that a message has already been printed.
12680
12681    If the bottom bit of TAG is set it assumed to have a
12682    string value, otherwise it is assumed to have an integer
12683    value.
12684
12685    Returns an updated P pointing to the first unread byte
12686    beyond the end of TAG's value.
12687
12688    Reads at or beyond END will not be made.  */
12689
12690 static unsigned char *
12691 display_tag_value (int tag,
12692                    unsigned char * p,
12693                    const unsigned char * const end)
12694 {
12695   unsigned long val;
12696
12697   if (tag > 0)
12698     printf ("  Tag_unknown_%d: ", tag);
12699
12700   if (p >= end)
12701     {
12702       warn (_("<corrupt tag>\n"));
12703     }
12704   else if (tag & 1)
12705     {
12706       /* PR 17531 file: 027-19978-0.004.  */
12707       size_t maxlen = (end - p) - 1;
12708
12709       putchar ('"');
12710       if (maxlen > 0)
12711         {
12712           print_symbol ((int) maxlen, (const char *) p);
12713           p += strnlen ((char *) p, maxlen) + 1;
12714         }
12715       else
12716         {
12717           printf (_("<corrupt string tag>"));
12718           p = (unsigned char *) end;
12719         }
12720       printf ("\"\n");
12721     }
12722   else
12723     {
12724       unsigned int len;
12725
12726       val = read_uleb128 (p, &len, end);
12727       p += len;
12728       printf ("%ld (0x%lx)\n", val, val);
12729     }
12730
12731   assert (p <= end);
12732   return p;
12733 }
12734
12735 /* ARM EABI attributes section.  */
12736 typedef struct
12737 {
12738   unsigned int tag;
12739   const char * name;
12740   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12741   unsigned int type;
12742   const char ** table;
12743 } arm_attr_public_tag;
12744
12745 static const char * arm_attr_tag_CPU_arch[] =
12746   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12747    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12748 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12749 static const char * arm_attr_tag_THUMB_ISA_use[] =
12750   {"No", "Thumb-1", "Thumb-2"};
12751 static const char * arm_attr_tag_FP_arch[] =
12752   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12753    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12754 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12755 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12756   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12757 static const char * arm_attr_tag_PCS_config[] =
12758   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12759    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12760 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12761   {"V6", "SB", "TLS", "Unused"};
12762 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12763   {"Absolute", "PC-relative", "SB-relative", "None"};
12764 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12765   {"Absolute", "PC-relative", "None"};
12766 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12767   {"None", "direct", "GOT-indirect"};
12768 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12769   {"None", "??? 1", "2", "??? 3", "4"};
12770 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12771 static const char * arm_attr_tag_ABI_FP_denormal[] =
12772   {"Unused", "Needed", "Sign only"};
12773 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12774 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12775 static const char * arm_attr_tag_ABI_FP_number_model[] =
12776   {"Unused", "Finite", "RTABI", "IEEE 754"};
12777 static const char * arm_attr_tag_ABI_enum_size[] =
12778   {"Unused", "small", "int", "forced to int"};
12779 static const char * arm_attr_tag_ABI_HardFP_use[] =
12780   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12781 static const char * arm_attr_tag_ABI_VFP_args[] =
12782   {"AAPCS", "VFP registers", "custom", "compatible"};
12783 static const char * arm_attr_tag_ABI_WMMX_args[] =
12784   {"AAPCS", "WMMX registers", "custom"};
12785 static const char * arm_attr_tag_ABI_optimization_goals[] =
12786   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12787     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12788 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12789   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12790     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12791 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12792 static const char * arm_attr_tag_FP_HP_extension[] =
12793   {"Not Allowed", "Allowed"};
12794 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12795   {"None", "IEEE 754", "Alternative Format"};
12796 static const char * arm_attr_tag_MPextension_use[] =
12797   {"Not Allowed", "Allowed"};
12798 static const char * arm_attr_tag_DIV_use[] =
12799   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12800     "Allowed in v7-A with integer division extension"};
12801 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12802 static const char * arm_attr_tag_Virtualization_use[] =
12803   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12804     "TrustZone and Virtualization Extensions"};
12805 static const char * arm_attr_tag_MPextension_use_legacy[] =
12806   {"Not Allowed", "Allowed"};
12807
12808 #define LOOKUP(id, name) \
12809   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12810 static arm_attr_public_tag arm_attr_public_tags[] =
12811 {
12812   {4, "CPU_raw_name", 1, NULL},
12813   {5, "CPU_name", 1, NULL},
12814   LOOKUP(6, CPU_arch),
12815   {7, "CPU_arch_profile", 0, NULL},
12816   LOOKUP(8, ARM_ISA_use),
12817   LOOKUP(9, THUMB_ISA_use),
12818   LOOKUP(10, FP_arch),
12819   LOOKUP(11, WMMX_arch),
12820   LOOKUP(12, Advanced_SIMD_arch),
12821   LOOKUP(13, PCS_config),
12822   LOOKUP(14, ABI_PCS_R9_use),
12823   LOOKUP(15, ABI_PCS_RW_data),
12824   LOOKUP(16, ABI_PCS_RO_data),
12825   LOOKUP(17, ABI_PCS_GOT_use),
12826   LOOKUP(18, ABI_PCS_wchar_t),
12827   LOOKUP(19, ABI_FP_rounding),
12828   LOOKUP(20, ABI_FP_denormal),
12829   LOOKUP(21, ABI_FP_exceptions),
12830   LOOKUP(22, ABI_FP_user_exceptions),
12831   LOOKUP(23, ABI_FP_number_model),
12832   {24, "ABI_align_needed", 0, NULL},
12833   {25, "ABI_align_preserved", 0, NULL},
12834   LOOKUP(26, ABI_enum_size),
12835   LOOKUP(27, ABI_HardFP_use),
12836   LOOKUP(28, ABI_VFP_args),
12837   LOOKUP(29, ABI_WMMX_args),
12838   LOOKUP(30, ABI_optimization_goals),
12839   LOOKUP(31, ABI_FP_optimization_goals),
12840   {32, "compatibility", 0, NULL},
12841   LOOKUP(34, CPU_unaligned_access),
12842   LOOKUP(36, FP_HP_extension),
12843   LOOKUP(38, ABI_FP_16bit_format),
12844   LOOKUP(42, MPextension_use),
12845   LOOKUP(44, DIV_use),
12846   {64, "nodefaults", 0, NULL},
12847   {65, "also_compatible_with", 0, NULL},
12848   LOOKUP(66, T2EE_use),
12849   {67, "conformance", 1, NULL},
12850   LOOKUP(68, Virtualization_use),
12851   LOOKUP(70, MPextension_use_legacy)
12852 };
12853 #undef LOOKUP
12854
12855 static unsigned char *
12856 display_arm_attribute (unsigned char * p,
12857                        const unsigned char * const end)
12858 {
12859   unsigned int tag;
12860   unsigned int len;
12861   unsigned int val;
12862   arm_attr_public_tag * attr;
12863   unsigned i;
12864   unsigned int type;
12865
12866   tag = read_uleb128 (p, &len, end);
12867   p += len;
12868   attr = NULL;
12869   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12870     {
12871       if (arm_attr_public_tags[i].tag == tag)
12872         {
12873           attr = &arm_attr_public_tags[i];
12874           break;
12875         }
12876     }
12877
12878   if (attr)
12879     {
12880       printf ("  Tag_%s: ", attr->name);
12881       switch (attr->type)
12882         {
12883         case 0:
12884           switch (tag)
12885             {
12886             case 7: /* Tag_CPU_arch_profile.  */
12887               val = read_uleb128 (p, &len, end);
12888               p += len;
12889               switch (val)
12890                 {
12891                 case 0: printf (_("None\n")); break;
12892                 case 'A': printf (_("Application\n")); break;
12893                 case 'R': printf (_("Realtime\n")); break;
12894                 case 'M': printf (_("Microcontroller\n")); break;
12895                 case 'S': printf (_("Application or Realtime\n")); break;
12896                 default: printf ("??? (%d)\n", val); break;
12897                 }
12898               break;
12899
12900             case 24: /* Tag_align_needed.  */
12901               val = read_uleb128 (p, &len, end);
12902               p += len;
12903               switch (val)
12904                 {
12905                 case 0: printf (_("None\n")); break;
12906                 case 1: printf (_("8-byte\n")); break;
12907                 case 2: printf (_("4-byte\n")); break;
12908                 case 3: printf ("??? 3\n"); break;
12909                 default:
12910                   if (val <= 12)
12911                     printf (_("8-byte and up to %d-byte extended\n"),
12912                             1 << val);
12913                   else
12914                     printf ("??? (%d)\n", val);
12915                   break;
12916                 }
12917               break;
12918
12919             case 25: /* Tag_align_preserved.  */
12920               val = read_uleb128 (p, &len, end);
12921               p += len;
12922               switch (val)
12923                 {
12924                 case 0: printf (_("None\n")); break;
12925                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12926                 case 2: printf (_("8-byte\n")); break;
12927                 case 3: printf ("??? 3\n"); break;
12928                 default:
12929                   if (val <= 12)
12930                     printf (_("8-byte and up to %d-byte extended\n"),
12931                             1 << val);
12932                   else
12933                     printf ("??? (%d)\n", val);
12934                   break;
12935                 }
12936               break;
12937
12938             case 32: /* Tag_compatibility.  */
12939               {
12940                 val = read_uleb128 (p, &len, end);
12941                 p += len;
12942                 printf (_("flag = %d, vendor = "), val);
12943                 if (p < end - 1)
12944                   {
12945                     size_t maxlen = (end - p) - 1;
12946
12947                     print_symbol ((int) maxlen, (const char *) p);
12948                     p += strnlen ((char *) p, maxlen) + 1;
12949                   }
12950                 else
12951                   {
12952                     printf (_("<corrupt>"));
12953                     p = (unsigned char *) end;
12954                   }
12955                 putchar ('\n');
12956               }
12957               break;
12958
12959             case 64: /* Tag_nodefaults.  */
12960               /* PR 17531: file: 001-505008-0.01.  */
12961               if (p < end)
12962                 p++;
12963               printf (_("True\n"));
12964               break;
12965
12966             case 65: /* Tag_also_compatible_with.  */
12967               val = read_uleb128 (p, &len, end);
12968               p += len;
12969               if (val == 6 /* Tag_CPU_arch.  */)
12970                 {
12971                   val = read_uleb128 (p, &len, end);
12972                   p += len;
12973                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12974                     printf ("??? (%d)\n", val);
12975                   else
12976                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12977                 }
12978               else
12979                 printf ("???\n");
12980               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12981                 ;
12982               break;
12983
12984             default:
12985               printf (_("<unknown: %d>\n"), tag);
12986               break;
12987             }
12988           return p;
12989
12990         case 1:
12991           return display_tag_value (-1, p, end);
12992         case 2:
12993           return display_tag_value (0, p, end);
12994
12995         default:
12996           assert (attr->type & 0x80);
12997           val = read_uleb128 (p, &len, end);
12998           p += len;
12999           type = attr->type & 0x7f;
13000           if (val >= type)
13001             printf ("??? (%d)\n", val);
13002           else
13003             printf ("%s\n", attr->table[val]);
13004           return p;
13005         }
13006     }
13007
13008   return display_tag_value (tag, p, end);
13009 }
13010
13011 static unsigned char *
13012 display_gnu_attribute (unsigned char * p,
13013                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13014                        const unsigned char * const end)
13015 {
13016   int tag;
13017   unsigned int len;
13018   int val;
13019
13020   tag = read_uleb128 (p, &len, end);
13021   p += len;
13022
13023   /* Tag_compatibility is the only generic GNU attribute defined at
13024      present.  */
13025   if (tag == 32)
13026     {
13027       val = read_uleb128 (p, &len, end);
13028       p += len;
13029
13030       printf (_("flag = %d, vendor = "), val);
13031       if (p == end)
13032         {
13033           printf (_("<corrupt>\n"));
13034           warn (_("corrupt vendor attribute\n"));
13035         }
13036       else
13037         {
13038           if (p < end - 1)
13039             {
13040               size_t maxlen = (end - p) - 1;
13041
13042               print_symbol ((int) maxlen, (const char *) p);
13043               p += strnlen ((char *) p, maxlen) + 1;
13044             }
13045           else
13046             {
13047               printf (_("<corrupt>"));
13048               p = (unsigned char *) end;
13049             }
13050           putchar ('\n');
13051         }
13052       return p;
13053     }
13054
13055   if ((tag & 2) == 0 && display_proc_gnu_attribute)
13056     return display_proc_gnu_attribute (p, tag, end);
13057
13058   return display_tag_value (tag, p, end);
13059 }
13060
13061 static unsigned char *
13062 display_power_gnu_attribute (unsigned char * p,
13063                              int tag,
13064                              const unsigned char * const end)
13065 {
13066   unsigned int len;
13067   int val;
13068
13069   if (tag == Tag_GNU_Power_ABI_FP)
13070     {
13071       val = read_uleb128 (p, &len, end);
13072       p += len;
13073       printf ("  Tag_GNU_Power_ABI_FP: ");
13074
13075       switch (val)
13076         {
13077         case 0:
13078           printf (_("Hard or soft float\n"));
13079           break;
13080         case 1:
13081           printf (_("Hard float\n"));
13082           break;
13083         case 2:
13084           printf (_("Soft float\n"));
13085           break;
13086         case 3:
13087           printf (_("Single-precision hard float\n"));
13088           break;
13089         default:
13090           printf ("??? (%d)\n", val);
13091           break;
13092         }
13093       return p;
13094    }
13095
13096   if (tag == Tag_GNU_Power_ABI_Vector)
13097     {
13098       val = read_uleb128 (p, &len, end);
13099       p += len;
13100       printf ("  Tag_GNU_Power_ABI_Vector: ");
13101       switch (val)
13102         {
13103         case 0:
13104           printf (_("Any\n"));
13105           break;
13106         case 1:
13107           printf (_("Generic\n"));
13108           break;
13109         case 2:
13110           printf ("AltiVec\n");
13111           break;
13112         case 3:
13113           printf ("SPE\n");
13114           break;
13115         default:
13116           printf ("??? (%d)\n", val);
13117           break;
13118         }
13119       return p;
13120    }
13121
13122   if (tag == Tag_GNU_Power_ABI_Struct_Return)
13123     {
13124       if (p == end)
13125         {
13126           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13127           return p;
13128         }
13129
13130       val = read_uleb128 (p, &len, end);
13131       p += len;
13132       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13133       switch (val)
13134        {
13135        case 0:
13136          printf (_("Any\n"));
13137          break;
13138        case 1:
13139          printf ("r3/r4\n");
13140          break;
13141        case 2:
13142          printf (_("Memory\n"));
13143          break;
13144        default:
13145          printf ("??? (%d)\n", val);
13146          break;
13147        }
13148       return p;
13149     }
13150
13151   return display_tag_value (tag & 1, p, end);
13152 }
13153
13154 static unsigned char *
13155 display_s390_gnu_attribute (unsigned char * p,
13156                             int tag,
13157                             const unsigned char * const end)
13158 {
13159   unsigned int len;
13160   int val;
13161
13162   if (tag == Tag_GNU_S390_ABI_Vector)
13163     {
13164       val = read_uleb128 (p, &len, end);
13165       p += len;
13166       printf ("  Tag_GNU_S390_ABI_Vector: ");
13167
13168       switch (val)
13169         {
13170         case 0:
13171           printf (_("any\n"));
13172           break;
13173         case 1:
13174           printf (_("software\n"));
13175           break;
13176         case 2:
13177           printf (_("hardware\n"));
13178           break;
13179         default:
13180           printf ("??? (%d)\n", val);
13181           break;
13182         }
13183       return p;
13184    }
13185
13186   return display_tag_value (tag & 1, p, end);
13187 }
13188
13189 static void
13190 display_sparc_hwcaps (int mask)
13191 {
13192   if (mask)
13193     {
13194       int first = 1;
13195
13196       if (mask & ELF_SPARC_HWCAP_MUL32)
13197         fputs ("mul32", stdout), first = 0;
13198       if (mask & ELF_SPARC_HWCAP_DIV32)
13199         printf ("%sdiv32", first ? "" : "|"), first = 0;
13200       if (mask & ELF_SPARC_HWCAP_FSMULD)
13201         printf ("%sfsmuld", first ? "" : "|"), first = 0;
13202       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13203         printf ("%sv8plus", first ? "" : "|"), first = 0;
13204       if (mask & ELF_SPARC_HWCAP_POPC)
13205         printf ("%spopc", first ? "" : "|"), first = 0;
13206       if (mask & ELF_SPARC_HWCAP_VIS)
13207         printf ("%svis", first ? "" : "|"), first = 0;
13208       if (mask & ELF_SPARC_HWCAP_VIS2)
13209         printf ("%svis2", first ? "" : "|"), first = 0;
13210       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13211         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13212       if (mask & ELF_SPARC_HWCAP_FMAF)
13213         printf ("%sfmaf", first ? "" : "|"), first = 0;
13214       if (mask & ELF_SPARC_HWCAP_VIS3)
13215         printf ("%svis3", first ? "" : "|"), first = 0;
13216       if (mask & ELF_SPARC_HWCAP_HPC)
13217         printf ("%shpc", first ? "" : "|"), first = 0;
13218       if (mask & ELF_SPARC_HWCAP_RANDOM)
13219         printf ("%srandom", first ? "" : "|"), first = 0;
13220       if (mask & ELF_SPARC_HWCAP_TRANS)
13221         printf ("%strans", first ? "" : "|"), first = 0;
13222       if (mask & ELF_SPARC_HWCAP_FJFMAU)
13223         printf ("%sfjfmau", first ? "" : "|"), first = 0;
13224       if (mask & ELF_SPARC_HWCAP_IMA)
13225         printf ("%sima", first ? "" : "|"), first = 0;
13226       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13227         printf ("%scspare", first ? "" : "|"), first = 0;
13228     }
13229   else
13230     fputc ('0', stdout);
13231   fputc ('\n', stdout);
13232 }
13233
13234 static void
13235 display_sparc_hwcaps2 (int mask)
13236 {
13237   if (mask)
13238     {
13239       int first = 1;
13240
13241       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13242         fputs ("fjathplus", stdout), first = 0;
13243       if (mask & ELF_SPARC_HWCAP2_VIS3B)
13244         printf ("%svis3b", first ? "" : "|"), first = 0;
13245       if (mask & ELF_SPARC_HWCAP2_ADP)
13246         printf ("%sadp", first ? "" : "|"), first = 0;
13247       if (mask & ELF_SPARC_HWCAP2_SPARC5)
13248         printf ("%ssparc5", first ? "" : "|"), first = 0;
13249       if (mask & ELF_SPARC_HWCAP2_MWAIT)
13250         printf ("%smwait", first ? "" : "|"), first = 0;
13251       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13252         printf ("%sxmpmul", first ? "" : "|"), first = 0;
13253       if (mask & ELF_SPARC_HWCAP2_XMONT)
13254         printf ("%sxmont2", first ? "" : "|"), first = 0;
13255       if (mask & ELF_SPARC_HWCAP2_NSEC)
13256         printf ("%snsec", first ? "" : "|"), first = 0;
13257       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13258         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13259       if (mask & ELF_SPARC_HWCAP2_FJDES)
13260         printf ("%sfjdes", first ? "" : "|"), first = 0;
13261       if (mask & ELF_SPARC_HWCAP2_FJAES)
13262         printf ("%sfjaes", first ? "" : "|"), first = 0;
13263     }
13264   else
13265     fputc ('0', stdout);
13266   fputc ('\n', stdout);
13267 }
13268
13269 static unsigned char *
13270 display_sparc_gnu_attribute (unsigned char * p,
13271                              int tag,
13272                              const unsigned char * const end)
13273 {
13274   unsigned int len;
13275   int val;
13276
13277   if (tag == Tag_GNU_Sparc_HWCAPS)
13278     {
13279       val = read_uleb128 (p, &len, end);
13280       p += len;
13281       printf ("  Tag_GNU_Sparc_HWCAPS: ");
13282       display_sparc_hwcaps (val);
13283       return p;
13284     }
13285   if (tag == Tag_GNU_Sparc_HWCAPS2)
13286     {
13287       val = read_uleb128 (p, &len, end);
13288       p += len;
13289       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
13290       display_sparc_hwcaps2 (val);
13291       return p;
13292     }
13293
13294   return display_tag_value (tag, p, end);
13295 }
13296
13297 static void
13298 print_mips_fp_abi_value (int val)
13299 {
13300   switch (val)
13301     {
13302     case Val_GNU_MIPS_ABI_FP_ANY:
13303       printf (_("Hard or soft float\n"));
13304       break;
13305     case Val_GNU_MIPS_ABI_FP_DOUBLE:
13306       printf (_("Hard float (double precision)\n"));
13307       break;
13308     case Val_GNU_MIPS_ABI_FP_SINGLE:
13309       printf (_("Hard float (single precision)\n"));
13310       break;
13311     case Val_GNU_MIPS_ABI_FP_SOFT:
13312       printf (_("Soft float\n"));
13313       break;
13314     case Val_GNU_MIPS_ABI_FP_OLD_64:
13315       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13316       break;
13317     case Val_GNU_MIPS_ABI_FP_XX:
13318       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13319       break;
13320     case Val_GNU_MIPS_ABI_FP_64:
13321       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13322       break;
13323     case Val_GNU_MIPS_ABI_FP_64A:
13324       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13325       break;
13326     case Val_GNU_MIPS_ABI_FP_NAN2008:
13327       printf (_("NaN 2008 compatibility\n"));
13328       break;
13329     default:
13330       printf ("??? (%d)\n", val);
13331       break;
13332     }
13333 }
13334
13335 static unsigned char *
13336 display_mips_gnu_attribute (unsigned char * p,
13337                             int tag,
13338                             const unsigned char * const end)
13339 {
13340   if (tag == Tag_GNU_MIPS_ABI_FP)
13341     {
13342       unsigned int len;
13343       int val;
13344
13345       val = read_uleb128 (p, &len, end);
13346       p += len;
13347       printf ("  Tag_GNU_MIPS_ABI_FP: ");
13348
13349       print_mips_fp_abi_value (val);
13350
13351       return p;
13352    }
13353
13354   if (tag == Tag_GNU_MIPS_ABI_MSA)
13355     {
13356       unsigned int len;
13357       int val;
13358
13359       val = read_uleb128 (p, &len, end);
13360       p += len;
13361       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
13362
13363       switch (val)
13364         {
13365         case Val_GNU_MIPS_ABI_MSA_ANY:
13366           printf (_("Any MSA or not\n"));
13367           break;
13368         case Val_GNU_MIPS_ABI_MSA_128:
13369           printf (_("128-bit MSA\n"));
13370           break;
13371         default:
13372           printf ("??? (%d)\n", val);
13373           break;
13374         }
13375       return p;
13376     }
13377
13378   return display_tag_value (tag & 1, p, end);
13379 }
13380
13381 static unsigned char *
13382 display_tic6x_attribute (unsigned char * p,
13383                          const unsigned char * const end)
13384 {
13385   int tag;
13386   unsigned int len;
13387   int val;
13388
13389   tag = read_uleb128 (p, &len, end);
13390   p += len;
13391
13392   switch (tag)
13393     {
13394     case Tag_ISA:
13395       val = read_uleb128 (p, &len, end);
13396       p += len;
13397       printf ("  Tag_ISA: ");
13398
13399       switch (val)
13400         {
13401         case C6XABI_Tag_ISA_none:
13402           printf (_("None\n"));
13403           break;
13404         case C6XABI_Tag_ISA_C62X:
13405           printf ("C62x\n");
13406           break;
13407         case C6XABI_Tag_ISA_C67X:
13408           printf ("C67x\n");
13409           break;
13410         case C6XABI_Tag_ISA_C67XP:
13411           printf ("C67x+\n");
13412           break;
13413         case C6XABI_Tag_ISA_C64X:
13414           printf ("C64x\n");
13415           break;
13416         case C6XABI_Tag_ISA_C64XP:
13417           printf ("C64x+\n");
13418           break;
13419         case C6XABI_Tag_ISA_C674X:
13420           printf ("C674x\n");
13421           break;
13422         default:
13423           printf ("??? (%d)\n", val);
13424           break;
13425         }
13426       return p;
13427
13428     case Tag_ABI_wchar_t:
13429       val = read_uleb128 (p, &len, end);
13430       p += len;
13431       printf ("  Tag_ABI_wchar_t: ");
13432       switch (val)
13433         {
13434         case 0:
13435           printf (_("Not used\n"));
13436           break;
13437         case 1:
13438           printf (_("2 bytes\n"));
13439           break;
13440         case 2:
13441           printf (_("4 bytes\n"));
13442           break;
13443         default:
13444           printf ("??? (%d)\n", val);
13445           break;
13446         }
13447       return p;
13448
13449     case Tag_ABI_stack_align_needed:
13450       val = read_uleb128 (p, &len, end);
13451       p += len;
13452       printf ("  Tag_ABI_stack_align_needed: ");
13453       switch (val)
13454         {
13455         case 0:
13456           printf (_("8-byte\n"));
13457           break;
13458         case 1:
13459           printf (_("16-byte\n"));
13460           break;
13461         default:
13462           printf ("??? (%d)\n", val);
13463           break;
13464         }
13465       return p;
13466
13467     case Tag_ABI_stack_align_preserved:
13468       val = read_uleb128 (p, &len, end);
13469       p += len;
13470       printf ("  Tag_ABI_stack_align_preserved: ");
13471       switch (val)
13472         {
13473         case 0:
13474           printf (_("8-byte\n"));
13475           break;
13476         case 1:
13477           printf (_("16-byte\n"));
13478           break;
13479         default:
13480           printf ("??? (%d)\n", val);
13481           break;
13482         }
13483       return p;
13484
13485     case Tag_ABI_DSBT:
13486       val = read_uleb128 (p, &len, end);
13487       p += len;
13488       printf ("  Tag_ABI_DSBT: ");
13489       switch (val)
13490         {
13491         case 0:
13492           printf (_("DSBT addressing not used\n"));
13493           break;
13494         case 1:
13495           printf (_("DSBT addressing used\n"));
13496           break;
13497         default:
13498           printf ("??? (%d)\n", val);
13499           break;
13500         }
13501       return p;
13502
13503     case Tag_ABI_PID:
13504       val = read_uleb128 (p, &len, end);
13505       p += len;
13506       printf ("  Tag_ABI_PID: ");
13507       switch (val)
13508         {
13509         case 0:
13510           printf (_("Data addressing position-dependent\n"));
13511           break;
13512         case 1:
13513           printf (_("Data addressing position-independent, GOT near DP\n"));
13514           break;
13515         case 2:
13516           printf (_("Data addressing position-independent, GOT far from DP\n"));
13517           break;
13518         default:
13519           printf ("??? (%d)\n", val);
13520           break;
13521         }
13522       return p;
13523
13524     case Tag_ABI_PIC:
13525       val = read_uleb128 (p, &len, end);
13526       p += len;
13527       printf ("  Tag_ABI_PIC: ");
13528       switch (val)
13529         {
13530         case 0:
13531           printf (_("Code addressing position-dependent\n"));
13532           break;
13533         case 1:
13534           printf (_("Code addressing position-independent\n"));
13535           break;
13536         default:
13537           printf ("??? (%d)\n", val);
13538           break;
13539         }
13540       return p;
13541
13542     case Tag_ABI_array_object_alignment:
13543       val = read_uleb128 (p, &len, end);
13544       p += len;
13545       printf ("  Tag_ABI_array_object_alignment: ");
13546       switch (val)
13547         {
13548         case 0:
13549           printf (_("8-byte\n"));
13550           break;
13551         case 1:
13552           printf (_("4-byte\n"));
13553           break;
13554         case 2:
13555           printf (_("16-byte\n"));
13556           break;
13557         default:
13558           printf ("??? (%d)\n", val);
13559           break;
13560         }
13561       return p;
13562
13563     case Tag_ABI_array_object_align_expected:
13564       val = read_uleb128 (p, &len, end);
13565       p += len;
13566       printf ("  Tag_ABI_array_object_align_expected: ");
13567       switch (val)
13568         {
13569         case 0:
13570           printf (_("8-byte\n"));
13571           break;
13572         case 1:
13573           printf (_("4-byte\n"));
13574           break;
13575         case 2:
13576           printf (_("16-byte\n"));
13577           break;
13578         default:
13579           printf ("??? (%d)\n", val);
13580           break;
13581         }
13582       return p;
13583
13584     case Tag_ABI_compatibility:
13585       {
13586         val = read_uleb128 (p, &len, end);
13587         p += len;
13588         printf ("  Tag_ABI_compatibility: ");
13589         printf (_("flag = %d, vendor = "), val);
13590         if (p < end - 1)
13591           {
13592             size_t maxlen = (end - p) - 1;
13593
13594             print_symbol ((int) maxlen, (const char *) p);
13595             p += strnlen ((char *) p, maxlen) + 1;
13596           }
13597         else
13598           {
13599             printf (_("<corrupt>"));
13600             p = (unsigned char *) end;
13601           }
13602         putchar ('\n');
13603         return p;
13604       }
13605
13606     case Tag_ABI_conformance:
13607       {
13608         printf ("  Tag_ABI_conformance: \"");
13609         if (p < end - 1)
13610           {
13611             size_t maxlen = (end - p) - 1;
13612
13613             print_symbol ((int) maxlen, (const char *) p);
13614             p += strnlen ((char *) p, maxlen) + 1;
13615           }
13616         else
13617           {
13618             printf (_("<corrupt>"));
13619             p = (unsigned char *) end;
13620           }
13621         printf ("\"\n");
13622         return p;
13623       }
13624     }
13625
13626   return display_tag_value (tag, p, end);
13627 }
13628
13629 static void
13630 display_raw_attribute (unsigned char * p, unsigned char * end)
13631 {
13632   unsigned long addr = 0;
13633   size_t bytes = end - p;
13634
13635   assert (end > p);
13636   while (bytes)
13637     {
13638       int j;
13639       int k;
13640       int lbytes = (bytes > 16 ? 16 : bytes);
13641
13642       printf ("  0x%8.8lx ", addr);
13643
13644       for (j = 0; j < 16; j++)
13645         {
13646           if (j < lbytes)
13647             printf ("%2.2x", p[j]);
13648           else
13649             printf ("  ");
13650
13651           if ((j & 3) == 3)
13652             printf (" ");
13653         }
13654
13655       for (j = 0; j < lbytes; j++)
13656         {
13657           k = p[j];
13658           if (k >= ' ' && k < 0x7f)
13659             printf ("%c", k);
13660           else
13661             printf (".");
13662         }
13663
13664       putchar ('\n');
13665
13666       p  += lbytes;
13667       bytes -= lbytes;
13668       addr += lbytes;
13669     }
13670
13671   putchar ('\n');
13672 }
13673
13674 static unsigned char *
13675 display_msp430x_attribute (unsigned char * p,
13676                            const unsigned char * const end)
13677 {
13678   unsigned int len;
13679   int val;
13680   int tag;
13681
13682   tag = read_uleb128 (p, & len, end);
13683   p += len;
13684
13685   switch (tag)
13686     {
13687     case OFBA_MSPABI_Tag_ISA:
13688       val = read_uleb128 (p, &len, end);
13689       p += len;
13690       printf ("  Tag_ISA: ");
13691       switch (val)
13692         {
13693         case 0: printf (_("None\n")); break;
13694         case 1: printf (_("MSP430\n")); break;
13695         case 2: printf (_("MSP430X\n")); break;
13696         default: printf ("??? (%d)\n", val); break;
13697         }
13698       break;
13699
13700     case OFBA_MSPABI_Tag_Code_Model:
13701       val = read_uleb128 (p, &len, end);
13702       p += len;
13703       printf ("  Tag_Code_Model: ");
13704       switch (val)
13705         {
13706         case 0: printf (_("None\n")); break;
13707         case 1: printf (_("Small\n")); break;
13708         case 2: printf (_("Large\n")); break;
13709         default: printf ("??? (%d)\n", val); break;
13710         }
13711       break;
13712
13713     case OFBA_MSPABI_Tag_Data_Model:
13714       val = read_uleb128 (p, &len, end);
13715       p += len;
13716       printf ("  Tag_Data_Model: ");
13717       switch (val)
13718         {
13719         case 0: printf (_("None\n")); break;
13720         case 1: printf (_("Small\n")); break;
13721         case 2: printf (_("Large\n")); break;
13722         case 3: printf (_("Restricted Large\n")); break;
13723         default: printf ("??? (%d)\n", val); break;
13724         }
13725       break;
13726
13727     default:
13728       printf (_("  <unknown tag %d>: "), tag);
13729
13730       if (tag & 1)
13731         {
13732           putchar ('"');
13733           if (p < end - 1)
13734             {
13735               size_t maxlen = (end - p) - 1;
13736
13737               print_symbol ((int) maxlen, (const char *) p);
13738               p += strnlen ((char *) p, maxlen) + 1;
13739             }
13740           else
13741             {
13742               printf (_("<corrupt>"));
13743               p = (unsigned char *) end;
13744             }
13745           printf ("\"\n");
13746         }
13747       else
13748         {
13749           val = read_uleb128 (p, &len, end);
13750           p += len;
13751           printf ("%d (0x%x)\n", val, val);
13752         }
13753       break;
13754    }
13755
13756   assert (p <= end);
13757   return p;
13758 }
13759
13760 static int
13761 process_attributes (FILE * file,
13762                     const char * public_name,
13763                     unsigned int proc_type,
13764                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13765                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13766 {
13767   Elf_Internal_Shdr * sect;
13768   unsigned i;
13769
13770   /* Find the section header so that we get the size.  */
13771   for (i = 0, sect = section_headers;
13772        i < elf_header.e_shnum;
13773        i++, sect++)
13774     {
13775       unsigned char * contents;
13776       unsigned char * p;
13777
13778       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13779         continue;
13780
13781       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13782                                              sect->sh_size, _("attributes"));
13783       if (contents == NULL)
13784         continue;
13785
13786       p = contents;
13787       if (*p == 'A')
13788         {
13789           bfd_vma section_len;
13790
13791           section_len = sect->sh_size - 1;
13792           p++;
13793
13794           while (section_len > 0)
13795             {
13796               bfd_vma attr_len;
13797               unsigned int namelen;
13798               bfd_boolean public_section;
13799               bfd_boolean gnu_section;
13800
13801               if (section_len <= 4)
13802                 {
13803                   error (_("Tag section ends prematurely\n"));
13804                   break;
13805                 }
13806               attr_len = byte_get (p, 4);
13807               p += 4;
13808
13809               if (attr_len > section_len)
13810                 {
13811                   error (_("Bad attribute length (%u > %u)\n"),
13812                           (unsigned) attr_len, (unsigned) section_len);
13813                   attr_len = section_len;
13814                 }
13815               /* PR 17531: file: 001-101425-0.004  */
13816               else if (attr_len < 5)
13817                 {
13818                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13819                   break;
13820                 }
13821
13822               section_len -= attr_len;
13823               attr_len -= 4;
13824
13825               namelen = strnlen ((char *) p, attr_len) + 1;
13826               if (namelen == 0 || namelen >= attr_len)
13827                 {
13828                   error (_("Corrupt attribute section name\n"));
13829                   break;
13830                 }
13831
13832               printf (_("Attribute Section: "));
13833               print_symbol (INT_MAX, (const char *) p);
13834               putchar ('\n');
13835
13836               if (public_name && streq ((char *) p, public_name))
13837                 public_section = TRUE;
13838               else
13839                 public_section = FALSE;
13840
13841               if (streq ((char *) p, "gnu"))
13842                 gnu_section = TRUE;
13843               else
13844                 gnu_section = FALSE;
13845
13846               p += namelen;
13847               attr_len -= namelen;
13848
13849               while (attr_len > 0 && p < contents + sect->sh_size)
13850                 {
13851                   int tag;
13852                   int val;
13853                   bfd_vma size;
13854                   unsigned char * end;
13855
13856                   /* PR binutils/17531: Safe handling of corrupt files.  */
13857                   if (attr_len < 6)
13858                     {
13859                       error (_("Unused bytes at end of section\n"));
13860                       section_len = 0;
13861                       break;
13862                     }
13863
13864                   tag = *(p++);
13865                   size = byte_get (p, 4);
13866                   if (size > attr_len)
13867                     {
13868                       error (_("Bad subsection length (%u > %u)\n"),
13869                               (unsigned) size, (unsigned) attr_len);
13870                       size = attr_len;
13871                     }
13872                   /* PR binutils/17531: Safe handling of corrupt files.  */
13873                   if (size < 6)
13874                     {
13875                       error (_("Bad subsection length (%u < 6)\n"),
13876                               (unsigned) size);
13877                       section_len = 0;
13878                       break;
13879                     }
13880
13881                   attr_len -= size;
13882                   end = p + size - 1;
13883                   assert (end <= contents + sect->sh_size);
13884                   p += 4;
13885
13886                   switch (tag)
13887                     {
13888                     case 1:
13889                       printf (_("File Attributes\n"));
13890                       break;
13891                     case 2:
13892                       printf (_("Section Attributes:"));
13893                       goto do_numlist;
13894                     case 3:
13895                       printf (_("Symbol Attributes:"));
13896                     do_numlist:
13897                       for (;;)
13898                         {
13899                           unsigned int j;
13900
13901                           val = read_uleb128 (p, &j, end);
13902                           p += j;
13903                           if (val == 0)
13904                             break;
13905                           printf (" %d", val);
13906                         }
13907                       printf ("\n");
13908                       break;
13909                     default:
13910                       printf (_("Unknown tag: %d\n"), tag);
13911                       public_section = FALSE;
13912                       break;
13913                     }
13914
13915                   if (public_section && display_pub_attribute != NULL)
13916                     {
13917                       while (p < end)
13918                         p = display_pub_attribute (p, end);
13919                       assert (p <= end);
13920                     }
13921                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13922                     {
13923                       while (p < end)
13924                         p = display_gnu_attribute (p,
13925                                                    display_proc_gnu_attribute,
13926                                                    end);
13927                       assert (p <= end);
13928                     }
13929                   else if (p < end)
13930                     {
13931                       printf (_("  Unknown attribute:\n"));
13932                       display_raw_attribute (p, end);
13933                       p = end;
13934                     }
13935                   else
13936                     attr_len = 0;
13937                 }
13938             }
13939         }
13940       else
13941         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13942
13943       free (contents);
13944     }
13945   return 1;
13946 }
13947
13948 static int
13949 process_arm_specific (FILE * file)
13950 {
13951   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13952                              display_arm_attribute, NULL);
13953 }
13954
13955 static int
13956 process_power_specific (FILE * file)
13957 {
13958   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13959                              display_power_gnu_attribute);
13960 }
13961
13962 static int
13963 process_s390_specific (FILE * file)
13964 {
13965   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13966                              display_s390_gnu_attribute);
13967 }
13968
13969 static int
13970 process_sparc_specific (FILE * file)
13971 {
13972   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13973                              display_sparc_gnu_attribute);
13974 }
13975
13976 static int
13977 process_tic6x_specific (FILE * file)
13978 {
13979   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13980                              display_tic6x_attribute, NULL);
13981 }
13982
13983 static int
13984 process_msp430x_specific (FILE * file)
13985 {
13986   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13987                              display_msp430x_attribute, NULL);
13988 }
13989
13990 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13991    Print the Address, Access and Initial fields of an entry at VMA ADDR
13992    and return the VMA of the next entry, or -1 if there was a problem.
13993    Does not read from DATA_END or beyond.  */
13994
13995 static bfd_vma
13996 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13997                       unsigned char * data_end)
13998 {
13999   printf ("  ");
14000   print_vma (addr, LONG_HEX);
14001   printf (" ");
14002   if (addr < pltgot + 0xfff0)
14003     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14004   else
14005     printf ("%10s", "");
14006   printf (" ");
14007   if (data == NULL)
14008     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14009   else
14010     {
14011       bfd_vma entry;
14012       unsigned char * from = data + addr - pltgot;
14013
14014       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14015         {
14016           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14017           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14018           return (bfd_vma) -1;
14019         }
14020       else
14021         {
14022           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14023           print_vma (entry, LONG_HEX);
14024         }
14025     }
14026   return addr + (is_32bit_elf ? 4 : 8);
14027 }
14028
14029 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14030    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14031    ADDR and return the VMA of the next entry.  */
14032
14033 static bfd_vma
14034 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14035 {
14036   printf ("  ");
14037   print_vma (addr, LONG_HEX);
14038   printf (" ");
14039   if (data == NULL)
14040     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14041   else
14042     {
14043       bfd_vma entry;
14044
14045       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14046       print_vma (entry, LONG_HEX);
14047     }
14048   return addr + (is_32bit_elf ? 4 : 8);
14049 }
14050
14051 static void
14052 print_mips_ases (unsigned int mask)
14053 {
14054   if (mask & AFL_ASE_DSP)
14055     fputs ("\n\tDSP ASE", stdout);
14056   if (mask & AFL_ASE_DSPR2)
14057     fputs ("\n\tDSP R2 ASE", stdout);
14058   if (mask & AFL_ASE_EVA)
14059     fputs ("\n\tEnhanced VA Scheme", stdout);
14060   if (mask & AFL_ASE_MCU)
14061     fputs ("\n\tMCU (MicroController) ASE", stdout);
14062   if (mask & AFL_ASE_MDMX)
14063     fputs ("\n\tMDMX ASE", stdout);
14064   if (mask & AFL_ASE_MIPS3D)
14065     fputs ("\n\tMIPS-3D ASE", stdout);
14066   if (mask & AFL_ASE_MT)
14067     fputs ("\n\tMT ASE", stdout);
14068   if (mask & AFL_ASE_SMARTMIPS)
14069     fputs ("\n\tSmartMIPS ASE", stdout);
14070   if (mask & AFL_ASE_VIRT)
14071     fputs ("\n\tVZ ASE", stdout);
14072   if (mask & AFL_ASE_MSA)
14073     fputs ("\n\tMSA ASE", stdout);
14074   if (mask & AFL_ASE_MIPS16)
14075     fputs ("\n\tMIPS16 ASE", stdout);
14076   if (mask & AFL_ASE_MICROMIPS)
14077     fputs ("\n\tMICROMIPS ASE", stdout);
14078   if (mask & AFL_ASE_XPA)
14079     fputs ("\n\tXPA ASE", stdout);
14080   if (mask == 0)
14081     fprintf (stdout, "\n\t%s", _("None"));
14082   else if ((mask & ~AFL_ASE_MASK) != 0)
14083     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14084 }
14085
14086 static void
14087 print_mips_isa_ext (unsigned int isa_ext)
14088 {
14089   switch (isa_ext)
14090     {
14091     case 0:
14092       fputs (_("None"), stdout);
14093       break;
14094     case AFL_EXT_XLR:
14095       fputs ("RMI XLR", stdout);
14096       break;
14097     case AFL_EXT_OCTEON3:
14098       fputs ("Cavium Networks Octeon3", stdout);
14099       break;
14100     case AFL_EXT_OCTEON2:
14101       fputs ("Cavium Networks Octeon2", stdout);
14102       break;
14103     case AFL_EXT_OCTEONP:
14104       fputs ("Cavium Networks OcteonP", stdout);
14105       break;
14106     case AFL_EXT_LOONGSON_3A:
14107       fputs ("Loongson 3A", stdout);
14108       break;
14109     case AFL_EXT_OCTEON:
14110       fputs ("Cavium Networks Octeon", stdout);
14111       break;
14112     case AFL_EXT_5900:
14113       fputs ("Toshiba R5900", stdout);
14114       break;
14115     case AFL_EXT_4650:
14116       fputs ("MIPS R4650", stdout);
14117       break;
14118     case AFL_EXT_4010:
14119       fputs ("LSI R4010", stdout);
14120       break;
14121     case AFL_EXT_4100:
14122       fputs ("NEC VR4100", stdout);
14123       break;
14124     case AFL_EXT_3900:
14125       fputs ("Toshiba R3900", stdout);
14126       break;
14127     case AFL_EXT_10000:
14128       fputs ("MIPS R10000", stdout);
14129       break;
14130     case AFL_EXT_SB1:
14131       fputs ("Broadcom SB-1", stdout);
14132       break;
14133     case AFL_EXT_4111:
14134       fputs ("NEC VR4111/VR4181", stdout);
14135       break;
14136     case AFL_EXT_4120:
14137       fputs ("NEC VR4120", stdout);
14138       break;
14139     case AFL_EXT_5400:
14140       fputs ("NEC VR5400", stdout);
14141       break;
14142     case AFL_EXT_5500:
14143       fputs ("NEC VR5500", stdout);
14144       break;
14145     case AFL_EXT_LOONGSON_2E:
14146       fputs ("ST Microelectronics Loongson 2E", stdout);
14147       break;
14148     case AFL_EXT_LOONGSON_2F:
14149       fputs ("ST Microelectronics Loongson 2F", stdout);
14150       break;
14151     default:
14152       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14153     }
14154 }
14155
14156 static int
14157 get_mips_reg_size (int reg_size)
14158 {
14159   return (reg_size == AFL_REG_NONE) ? 0
14160          : (reg_size == AFL_REG_32) ? 32
14161          : (reg_size == AFL_REG_64) ? 64
14162          : (reg_size == AFL_REG_128) ? 128
14163          : -1;
14164 }
14165
14166 static int
14167 process_mips_specific (FILE * file)
14168 {
14169   Elf_Internal_Dyn * entry;
14170   Elf_Internal_Shdr *sect = NULL;
14171   size_t liblist_offset = 0;
14172   size_t liblistno = 0;
14173   size_t conflictsno = 0;
14174   size_t options_offset = 0;
14175   size_t conflicts_offset = 0;
14176   size_t pltrelsz = 0;
14177   size_t pltrel = 0;
14178   bfd_vma pltgot = 0;
14179   bfd_vma mips_pltgot = 0;
14180   bfd_vma jmprel = 0;
14181   bfd_vma local_gotno = 0;
14182   bfd_vma gotsym = 0;
14183   bfd_vma symtabno = 0;
14184
14185   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14186                       display_mips_gnu_attribute);
14187
14188   sect = find_section (".MIPS.abiflags");
14189
14190   if (sect != NULL)
14191     {
14192       Elf_External_ABIFlags_v0 *abiflags_ext;
14193       Elf_Internal_ABIFlags_v0 abiflags_in;
14194
14195       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14196         fputs ("\nCorrupt ABI Flags section.\n", stdout);
14197       else
14198         {
14199           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14200                                    sect->sh_size, _("MIPS ABI Flags section"));
14201           if (abiflags_ext)
14202             {
14203               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14204               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14205               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14206               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14207               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14208               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14209               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14210               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14211               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14212               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14213               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14214
14215               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14216               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14217               if (abiflags_in.isa_rev > 1)
14218                 printf ("r%d", abiflags_in.isa_rev);
14219               printf ("\nGPR size: %d",
14220                       get_mips_reg_size (abiflags_in.gpr_size));
14221               printf ("\nCPR1 size: %d",
14222                       get_mips_reg_size (abiflags_in.cpr1_size));
14223               printf ("\nCPR2 size: %d",
14224                       get_mips_reg_size (abiflags_in.cpr2_size));
14225               fputs ("\nFP ABI: ", stdout);
14226               print_mips_fp_abi_value (abiflags_in.fp_abi);
14227               fputs ("ISA Extension: ", stdout);
14228               print_mips_isa_ext (abiflags_in.isa_ext);
14229               fputs ("\nASEs:", stdout);
14230               print_mips_ases (abiflags_in.ases);
14231               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14232               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14233               fputc ('\n', stdout);
14234               free (abiflags_ext);
14235             }
14236         }
14237     }
14238
14239   /* We have a lot of special sections.  Thanks SGI!  */
14240   if (dynamic_section == NULL)
14241     /* No information available.  */
14242     return 0;
14243
14244   for (entry = dynamic_section;
14245        /* PR 17531 file: 012-50589-0.004.  */
14246        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14247        ++entry)
14248     switch (entry->d_tag)
14249       {
14250       case DT_MIPS_LIBLIST:
14251         liblist_offset
14252           = offset_from_vma (file, entry->d_un.d_val,
14253                              liblistno * sizeof (Elf32_External_Lib));
14254         break;
14255       case DT_MIPS_LIBLISTNO:
14256         liblistno = entry->d_un.d_val;
14257         break;
14258       case DT_MIPS_OPTIONS:
14259         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14260         break;
14261       case DT_MIPS_CONFLICT:
14262         conflicts_offset
14263           = offset_from_vma (file, entry->d_un.d_val,
14264                              conflictsno * sizeof (Elf32_External_Conflict));
14265         break;
14266       case DT_MIPS_CONFLICTNO:
14267         conflictsno = entry->d_un.d_val;
14268         break;
14269       case DT_PLTGOT:
14270         pltgot = entry->d_un.d_ptr;
14271         break;
14272       case DT_MIPS_LOCAL_GOTNO:
14273         local_gotno = entry->d_un.d_val;
14274         break;
14275       case DT_MIPS_GOTSYM:
14276         gotsym = entry->d_un.d_val;
14277         break;
14278       case DT_MIPS_SYMTABNO:
14279         symtabno = entry->d_un.d_val;
14280         break;
14281       case DT_MIPS_PLTGOT:
14282         mips_pltgot = entry->d_un.d_ptr;
14283         break;
14284       case DT_PLTREL:
14285         pltrel = entry->d_un.d_val;
14286         break;
14287       case DT_PLTRELSZ:
14288         pltrelsz = entry->d_un.d_val;
14289         break;
14290       case DT_JMPREL:
14291         jmprel = entry->d_un.d_ptr;
14292         break;
14293       default:
14294         break;
14295       }
14296
14297   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14298     {
14299       Elf32_External_Lib * elib;
14300       size_t cnt;
14301
14302       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14303                                               liblistno,
14304                                               sizeof (Elf32_External_Lib),
14305                                               _("liblist section data"));
14306       if (elib)
14307         {
14308           printf (_("\nSection '.liblist' contains %lu entries:\n"),
14309                   (unsigned long) liblistno);
14310           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
14311                  stdout);
14312
14313           for (cnt = 0; cnt < liblistno; ++cnt)
14314             {
14315               Elf32_Lib liblist;
14316               time_t atime;
14317               char timebuf[20];
14318               struct tm * tmp;
14319
14320               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14321               atime = BYTE_GET (elib[cnt].l_time_stamp);
14322               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14323               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14324               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14325
14326               tmp = gmtime (&atime);
14327               snprintf (timebuf, sizeof (timebuf),
14328                         "%04u-%02u-%02uT%02u:%02u:%02u",
14329                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14330                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14331
14332               printf ("%3lu: ", (unsigned long) cnt);
14333               if (VALID_DYNAMIC_NAME (liblist.l_name))
14334                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14335               else
14336                 printf (_("<corrupt: %9ld>"), liblist.l_name);
14337               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14338                       liblist.l_version);
14339
14340               if (liblist.l_flags == 0)
14341                 puts (_(" NONE"));
14342               else
14343                 {
14344                   static const struct
14345                   {
14346                     const char * name;
14347                     int bit;
14348                   }
14349                   l_flags_vals[] =
14350                   {
14351                     { " EXACT_MATCH", LL_EXACT_MATCH },
14352                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14353                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14354                     { " EXPORTS", LL_EXPORTS },
14355                     { " DELAY_LOAD", LL_DELAY_LOAD },
14356                     { " DELTA", LL_DELTA }
14357                   };
14358                   int flags = liblist.l_flags;
14359                   size_t fcnt;
14360
14361                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14362                     if ((flags & l_flags_vals[fcnt].bit) != 0)
14363                       {
14364                         fputs (l_flags_vals[fcnt].name, stdout);
14365                         flags ^= l_flags_vals[fcnt].bit;
14366                       }
14367                   if (flags != 0)
14368                     printf (" %#x", (unsigned int) flags);
14369
14370                   puts ("");
14371                 }
14372             }
14373
14374           free (elib);
14375         }
14376     }
14377
14378   if (options_offset != 0)
14379     {
14380       Elf_External_Options * eopt;
14381       Elf_Internal_Options * iopt;
14382       Elf_Internal_Options * option;
14383       size_t offset;
14384       int cnt;
14385       sect = section_headers;
14386
14387       /* Find the section header so that we get the size.  */
14388       sect = find_section_by_type (SHT_MIPS_OPTIONS);
14389       /* PR 17533 file: 012-277276-0.004.  */
14390       if (sect == NULL)
14391         {
14392           error (_("No MIPS_OPTIONS header found\n"));
14393           return 0;
14394         }
14395
14396       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14397                                                 sect->sh_size, _("options"));
14398       if (eopt)
14399         {
14400           iopt = (Elf_Internal_Options *)
14401               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14402           if (iopt == NULL)
14403             {
14404               error (_("Out of memory allocatinf space for MIPS options\n"));
14405               return 0;
14406             }
14407
14408           offset = cnt = 0;
14409           option = iopt;
14410
14411           while (offset <= sect->sh_size - sizeof (* eopt))
14412             {
14413               Elf_External_Options * eoption;
14414
14415               eoption = (Elf_External_Options *) ((char *) eopt + offset);
14416
14417               option->kind = BYTE_GET (eoption->kind);
14418               option->size = BYTE_GET (eoption->size);
14419               option->section = BYTE_GET (eoption->section);
14420               option->info = BYTE_GET (eoption->info);
14421
14422               /* PR 17531: file: ffa0fa3b.  */
14423               if (option->size < sizeof (* eopt)
14424                   || offset + option->size > sect->sh_size)
14425                 {
14426                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
14427                   return 0;
14428                 }
14429               offset += option->size;
14430
14431               ++option;
14432               ++cnt;
14433             }
14434
14435           printf (_("\nSection '%s' contains %d entries:\n"),
14436                   printable_section_name (sect), cnt);
14437
14438           option = iopt;
14439           offset = 0;
14440
14441           while (cnt-- > 0)
14442             {
14443               size_t len;
14444
14445               switch (option->kind)
14446                 {
14447                 case ODK_NULL:
14448                   /* This shouldn't happen.  */
14449                   printf (" NULL       %d %lx", option->section, option->info);
14450                   break;
14451                 case ODK_REGINFO:
14452                   printf (" REGINFO    ");
14453                   if (elf_header.e_machine == EM_MIPS)
14454                     {
14455                       /* 32bit form.  */
14456                       Elf32_External_RegInfo * ereg;
14457                       Elf32_RegInfo reginfo;
14458
14459                       ereg = (Elf32_External_RegInfo *) (option + 1);
14460                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14461                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14462                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14463                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14464                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14465                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14466
14467                       printf ("GPR %08lx  GP 0x%lx\n",
14468                               reginfo.ri_gprmask,
14469                               (unsigned long) reginfo.ri_gp_value);
14470                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14471                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14472                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14473                     }
14474                   else
14475                     {
14476                       /* 64 bit form.  */
14477                       Elf64_External_RegInfo * ereg;
14478                       Elf64_Internal_RegInfo reginfo;
14479
14480                       ereg = (Elf64_External_RegInfo *) (option + 1);
14481                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
14482                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14483                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14484                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14485                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14486                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
14487
14488                       printf ("GPR %08lx  GP 0x",
14489                               reginfo.ri_gprmask);
14490                       printf_vma (reginfo.ri_gp_value);
14491                       printf ("\n");
14492
14493                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
14494                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14495                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14496                     }
14497                   ++option;
14498                   continue;
14499                 case ODK_EXCEPTIONS:
14500                   fputs (" EXCEPTIONS fpe_min(", stdout);
14501                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14502                   fputs (") fpe_max(", stdout);
14503                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14504                   fputs (")", stdout);
14505
14506                   if (option->info & OEX_PAGE0)
14507                     fputs (" PAGE0", stdout);
14508                   if (option->info & OEX_SMM)
14509                     fputs (" SMM", stdout);
14510                   if (option->info & OEX_FPDBUG)
14511                     fputs (" FPDBUG", stdout);
14512                   if (option->info & OEX_DISMISS)
14513                     fputs (" DISMISS", stdout);
14514                   break;
14515                 case ODK_PAD:
14516                   fputs (" PAD       ", stdout);
14517                   if (option->info & OPAD_PREFIX)
14518                     fputs (" PREFIX", stdout);
14519                   if (option->info & OPAD_POSTFIX)
14520                     fputs (" POSTFIX", stdout);
14521                   if (option->info & OPAD_SYMBOL)
14522                     fputs (" SYMBOL", stdout);
14523                   break;
14524                 case ODK_HWPATCH:
14525                   fputs (" HWPATCH   ", stdout);
14526                   if (option->info & OHW_R4KEOP)
14527                     fputs (" R4KEOP", stdout);
14528                   if (option->info & OHW_R8KPFETCH)
14529                     fputs (" R8KPFETCH", stdout);
14530                   if (option->info & OHW_R5KEOP)
14531                     fputs (" R5KEOP", stdout);
14532                   if (option->info & OHW_R5KCVTL)
14533                     fputs (" R5KCVTL", stdout);
14534                   break;
14535                 case ODK_FILL:
14536                   fputs (" FILL       ", stdout);
14537                   /* XXX Print content of info word?  */
14538                   break;
14539                 case ODK_TAGS:
14540                   fputs (" TAGS       ", stdout);
14541                   /* XXX Print content of info word?  */
14542                   break;
14543                 case ODK_HWAND:
14544                   fputs (" HWAND     ", stdout);
14545                   if (option->info & OHWA0_R4KEOP_CHECKED)
14546                     fputs (" R4KEOP_CHECKED", stdout);
14547                   if (option->info & OHWA0_R4KEOP_CLEAN)
14548                     fputs (" R4KEOP_CLEAN", stdout);
14549                   break;
14550                 case ODK_HWOR:
14551                   fputs (" HWOR      ", stdout);
14552                   if (option->info & OHWA0_R4KEOP_CHECKED)
14553                     fputs (" R4KEOP_CHECKED", stdout);
14554                   if (option->info & OHWA0_R4KEOP_CLEAN)
14555                     fputs (" R4KEOP_CLEAN", stdout);
14556                   break;
14557                 case ODK_GP_GROUP:
14558                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14559                           option->info & OGP_GROUP,
14560                           (option->info & OGP_SELF) >> 16);
14561                   break;
14562                 case ODK_IDENT:
14563                   printf (" IDENT     %#06lx  self-contained %#06lx",
14564                           option->info & OGP_GROUP,
14565                           (option->info & OGP_SELF) >> 16);
14566                   break;
14567                 default:
14568                   /* This shouldn't happen.  */
14569                   printf (" %3d ???     %d %lx",
14570                           option->kind, option->section, option->info);
14571                   break;
14572                 }
14573
14574               len = sizeof (* eopt);
14575               while (len < option->size)
14576                 {
14577                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
14578
14579                   if (ISPRINT (datum))
14580                     printf ("%c", datum);
14581                   else
14582                     printf ("\\%03o", datum);
14583                   len ++;
14584                 }
14585               fputs ("\n", stdout);
14586
14587               offset += option->size;
14588               ++option;
14589             }
14590
14591           free (eopt);
14592         }
14593     }
14594
14595   if (conflicts_offset != 0 && conflictsno != 0)
14596     {
14597       Elf32_Conflict * iconf;
14598       size_t cnt;
14599
14600       if (dynamic_symbols == NULL)
14601         {
14602           error (_("conflict list found without a dynamic symbol table\n"));
14603           return 0;
14604         }
14605
14606       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14607       if (iconf == NULL)
14608         {
14609           error (_("Out of memory allocating space for dynamic conflicts\n"));
14610           return 0;
14611         }
14612
14613       if (is_32bit_elf)
14614         {
14615           Elf32_External_Conflict * econf32;
14616
14617           econf32 = (Elf32_External_Conflict *)
14618               get_data (NULL, file, conflicts_offset, conflictsno,
14619                         sizeof (* econf32), _("conflict"));
14620           if (!econf32)
14621             return 0;
14622
14623           for (cnt = 0; cnt < conflictsno; ++cnt)
14624             iconf[cnt] = BYTE_GET (econf32[cnt]);
14625
14626           free (econf32);
14627         }
14628       else
14629         {
14630           Elf64_External_Conflict * econf64;
14631
14632           econf64 = (Elf64_External_Conflict *)
14633               get_data (NULL, file, conflicts_offset, conflictsno,
14634                         sizeof (* econf64), _("conflict"));
14635           if (!econf64)
14636             return 0;
14637
14638           for (cnt = 0; cnt < conflictsno; ++cnt)
14639             iconf[cnt] = BYTE_GET (econf64[cnt]);
14640
14641           free (econf64);
14642         }
14643
14644       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14645               (unsigned long) conflictsno);
14646       puts (_("  Num:    Index       Value  Name"));
14647
14648       for (cnt = 0; cnt < conflictsno; ++cnt)
14649         {
14650           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14651
14652           if (iconf[cnt] >= num_dynamic_syms)
14653             printf (_("<corrupt symbol index>"));
14654           else
14655             {
14656               Elf_Internal_Sym * psym;
14657
14658               psym = & dynamic_symbols[iconf[cnt]];
14659               print_vma (psym->st_value, FULL_HEX);
14660               putchar (' ');
14661               if (VALID_DYNAMIC_NAME (psym->st_name))
14662                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14663               else
14664                 printf (_("<corrupt: %14ld>"), psym->st_name);
14665             }
14666           putchar ('\n');
14667         }
14668
14669       free (iconf);
14670     }
14671
14672   if (pltgot != 0 && local_gotno != 0)
14673     {
14674       bfd_vma ent, local_end, global_end;
14675       size_t i, offset;
14676       unsigned char * data;
14677       unsigned char * data_end;
14678       int addr_size;
14679
14680       ent = pltgot;
14681       addr_size = (is_32bit_elf ? 4 : 8);
14682       local_end = pltgot + local_gotno * addr_size;
14683
14684       /* PR binutils/17533 file: 012-111227-0.004  */
14685       if (symtabno < gotsym)
14686         {
14687           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14688                  (unsigned long) gotsym, (unsigned long) symtabno);
14689           return 0;
14690         }
14691
14692       global_end = local_end + (symtabno - gotsym) * addr_size;
14693       /* PR 17531: file: 54c91a34.  */
14694       if (global_end < local_end)
14695         {
14696           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14697           return 0;
14698         }
14699
14700       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14701       data = (unsigned char *) get_data (NULL, file, offset,
14702                                          global_end - pltgot, 1,
14703                                          _("Global Offset Table data"));
14704       if (data == NULL)
14705         return 0;
14706       data_end = data + (global_end - pltgot);
14707
14708       printf (_("\nPrimary GOT:\n"));
14709       printf (_(" Canonical gp value: "));
14710       print_vma (pltgot + 0x7ff0, LONG_HEX);
14711       printf ("\n\n");
14712
14713       printf (_(" Reserved entries:\n"));
14714       printf (_("  %*s %10s %*s Purpose\n"),
14715               addr_size * 2, _("Address"), _("Access"),
14716               addr_size * 2, _("Initial"));
14717       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14718       printf (_(" Lazy resolver\n"));
14719       if (ent == (bfd_vma) -1)
14720         goto got_print_fail;
14721       if (data
14722           && (byte_get (data + ent - pltgot, addr_size)
14723               >> (addr_size * 8 - 1)) != 0)
14724         {
14725           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14726           printf (_(" Module pointer (GNU extension)\n"));
14727           if (ent == (bfd_vma) -1)
14728             goto got_print_fail;
14729         }
14730       printf ("\n");
14731
14732       if (ent < local_end)
14733         {
14734           printf (_(" Local entries:\n"));
14735           printf ("  %*s %10s %*s\n",
14736                   addr_size * 2, _("Address"), _("Access"),
14737                   addr_size * 2, _("Initial"));
14738           while (ent < local_end)
14739             {
14740               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14741               printf ("\n");
14742               if (ent == (bfd_vma) -1)
14743                 goto got_print_fail;
14744             }
14745           printf ("\n");
14746         }
14747
14748       if (gotsym < symtabno)
14749         {
14750           int sym_width;
14751
14752           printf (_(" Global entries:\n"));
14753           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14754                   addr_size * 2, _("Address"),
14755                   _("Access"),
14756                   addr_size * 2, _("Initial"),
14757                   addr_size * 2, _("Sym.Val."),
14758                   _("Type"),
14759                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14760                   _("Ndx"), _("Name"));
14761
14762           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14763
14764           for (i = gotsym; i < symtabno; i++)
14765             {
14766               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14767               printf (" ");
14768
14769               if (dynamic_symbols == NULL)
14770                 printf (_("<no dynamic symbols>"));
14771               else if (i < num_dynamic_syms)
14772                 {
14773                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14774
14775                   print_vma (psym->st_value, LONG_HEX);
14776                   printf (" %-7s %3s ",
14777                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14778                           get_symbol_index_type (psym->st_shndx));
14779
14780                   if (VALID_DYNAMIC_NAME (psym->st_name))
14781                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14782                   else
14783                     printf (_("<corrupt: %14ld>"), psym->st_name);
14784                 }
14785               else
14786                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14787                         (unsigned long) i);
14788
14789               printf ("\n");
14790               if (ent == (bfd_vma) -1)
14791                 break;
14792             }
14793           printf ("\n");
14794         }
14795
14796     got_print_fail:
14797       if (data)
14798         free (data);
14799     }
14800
14801   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14802     {
14803       bfd_vma ent, end;
14804       size_t offset, rel_offset;
14805       unsigned long count, i;
14806       unsigned char * data;
14807       int addr_size, sym_width;
14808       Elf_Internal_Rela * rels;
14809
14810       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14811       if (pltrel == DT_RELA)
14812         {
14813           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14814             return 0;
14815         }
14816       else
14817         {
14818           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14819             return 0;
14820         }
14821
14822       ent = mips_pltgot;
14823       addr_size = (is_32bit_elf ? 4 : 8);
14824       end = mips_pltgot + (2 + count) * addr_size;
14825
14826       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14827       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14828                                          1, _("Procedure Linkage Table data"));
14829       if (data == NULL)
14830         return 0;
14831
14832       printf ("\nPLT GOT:\n\n");
14833       printf (_(" Reserved entries:\n"));
14834       printf (_("  %*s %*s Purpose\n"),
14835               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14836       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14837       printf (_(" PLT lazy resolver\n"));
14838       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14839       printf (_(" Module pointer\n"));
14840       printf ("\n");
14841
14842       printf (_(" Entries:\n"));
14843       printf ("  %*s %*s %*s %-7s %3s %s\n",
14844               addr_size * 2, _("Address"),
14845               addr_size * 2, _("Initial"),
14846               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14847       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14848       for (i = 0; i < count; i++)
14849         {
14850           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14851
14852           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14853           printf (" ");
14854
14855           if (idx >= num_dynamic_syms)
14856             printf (_("<corrupt symbol index: %lu>"), idx);
14857           else
14858             {
14859               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14860
14861               print_vma (psym->st_value, LONG_HEX);
14862               printf (" %-7s %3s ",
14863                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14864                       get_symbol_index_type (psym->st_shndx));
14865               if (VALID_DYNAMIC_NAME (psym->st_name))
14866                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14867               else
14868                 printf (_("<corrupt: %14ld>"), psym->st_name);
14869             }
14870           printf ("\n");
14871         }
14872       printf ("\n");
14873
14874       if (data)
14875         free (data);
14876       free (rels);
14877     }
14878
14879   return 1;
14880 }
14881
14882 static int
14883 process_nds32_specific (FILE * file)
14884 {
14885   Elf_Internal_Shdr *sect = NULL;
14886
14887   sect = find_section (".nds32_e_flags");
14888   if (sect != NULL)
14889     {
14890       unsigned int *flag;
14891
14892       printf ("\nNDS32 elf flags section:\n");
14893       flag = get_data (NULL, file, sect->sh_offset, 1,
14894                        sect->sh_size, _("NDS32 elf flags section"));
14895
14896       switch ((*flag) & 0x3)
14897         {
14898         case 0:
14899           printf ("(VEC_SIZE):\tNo entry.\n");
14900           break;
14901         case 1:
14902           printf ("(VEC_SIZE):\t4 bytes\n");
14903           break;
14904         case 2:
14905           printf ("(VEC_SIZE):\t16 bytes\n");
14906           break;
14907         case 3:
14908           printf ("(VEC_SIZE):\treserved\n");
14909           break;
14910         }
14911     }
14912
14913   return TRUE;
14914 }
14915
14916 static int
14917 process_gnu_liblist (FILE * file)
14918 {
14919   Elf_Internal_Shdr * section;
14920   Elf_Internal_Shdr * string_sec;
14921   Elf32_External_Lib * elib;
14922   char * strtab;
14923   size_t strtab_size;
14924   size_t cnt;
14925   unsigned i;
14926
14927   if (! do_arch)
14928     return 0;
14929
14930   for (i = 0, section = section_headers;
14931        i < elf_header.e_shnum;
14932        i++, section++)
14933     {
14934       switch (section->sh_type)
14935         {
14936         case SHT_GNU_LIBLIST:
14937           if (section->sh_link >= elf_header.e_shnum)
14938             break;
14939
14940           elib = (Elf32_External_Lib *)
14941               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14942                         _("liblist section data"));
14943
14944           if (elib == NULL)
14945             break;
14946           string_sec = section_headers + section->sh_link;
14947
14948           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14949                                       string_sec->sh_size,
14950                                       _("liblist string table"));
14951           if (strtab == NULL
14952               || section->sh_entsize != sizeof (Elf32_External_Lib))
14953             {
14954               free (elib);
14955               free (strtab);
14956               break;
14957             }
14958           strtab_size = string_sec->sh_size;
14959
14960           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14961                   printable_section_name (section),
14962                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14963
14964           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14965
14966           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14967                ++cnt)
14968             {
14969               Elf32_Lib liblist;
14970               time_t atime;
14971               char timebuf[20];
14972               struct tm * tmp;
14973
14974               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14975               atime = BYTE_GET (elib[cnt].l_time_stamp);
14976               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14977               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14978               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14979
14980               tmp = gmtime (&atime);
14981               snprintf (timebuf, sizeof (timebuf),
14982                         "%04u-%02u-%02uT%02u:%02u:%02u",
14983                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14984                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14985
14986               printf ("%3lu: ", (unsigned long) cnt);
14987               if (do_wide)
14988                 printf ("%-20s", liblist.l_name < strtab_size
14989                         ? strtab + liblist.l_name : _("<corrupt>"));
14990               else
14991                 printf ("%-20.20s", liblist.l_name < strtab_size
14992                         ? strtab + liblist.l_name : _("<corrupt>"));
14993               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14994                       liblist.l_version, liblist.l_flags);
14995             }
14996
14997           free (elib);
14998           free (strtab);
14999         }
15000     }
15001
15002   return 1;
15003 }
15004
15005 static const char *
15006 get_note_type (unsigned e_type)
15007 {
15008   static char buff[64];
15009
15010   if (elf_header.e_type == ET_CORE)
15011     switch (e_type)
15012       {
15013       case NT_AUXV:
15014         return _("NT_AUXV (auxiliary vector)");
15015       case NT_PRSTATUS:
15016         return _("NT_PRSTATUS (prstatus structure)");
15017       case NT_FPREGSET:
15018         return _("NT_FPREGSET (floating point registers)");
15019       case NT_PRPSINFO:
15020         return _("NT_PRPSINFO (prpsinfo structure)");
15021       case NT_TASKSTRUCT:
15022         return _("NT_TASKSTRUCT (task structure)");
15023       case NT_PRXFPREG:
15024         return _("NT_PRXFPREG (user_xfpregs structure)");
15025       case NT_PPC_VMX:
15026         return _("NT_PPC_VMX (ppc Altivec registers)");
15027       case NT_PPC_VSX:
15028         return _("NT_PPC_VSX (ppc VSX registers)");
15029       case NT_386_TLS:
15030         return _("NT_386_TLS (x86 TLS information)");
15031       case NT_386_IOPERM:
15032         return _("NT_386_IOPERM (x86 I/O permissions)");
15033       case NT_X86_XSTATE:
15034         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15035       case NT_S390_HIGH_GPRS:
15036         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15037       case NT_S390_TIMER:
15038         return _("NT_S390_TIMER (s390 timer register)");
15039       case NT_S390_TODCMP:
15040         return _("NT_S390_TODCMP (s390 TOD comparator register)");
15041       case NT_S390_TODPREG:
15042         return _("NT_S390_TODPREG (s390 TOD programmable register)");
15043       case NT_S390_CTRS:
15044         return _("NT_S390_CTRS (s390 control registers)");
15045       case NT_S390_PREFIX:
15046         return _("NT_S390_PREFIX (s390 prefix register)");
15047       case NT_S390_LAST_BREAK:
15048         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15049       case NT_S390_SYSTEM_CALL:
15050         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15051       case NT_S390_TDB:
15052         return _("NT_S390_TDB (s390 transaction diagnostic block)");
15053       case NT_S390_VXRS_LOW:
15054         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15055       case NT_S390_VXRS_HIGH:
15056         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15057       case NT_ARM_VFP:
15058         return _("NT_ARM_VFP (arm VFP registers)");
15059       case NT_ARM_TLS:
15060         return _("NT_ARM_TLS (AArch TLS registers)");
15061       case NT_ARM_HW_BREAK:
15062         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15063       case NT_ARM_HW_WATCH:
15064         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15065       case NT_PSTATUS:
15066         return _("NT_PSTATUS (pstatus structure)");
15067       case NT_FPREGS:
15068         return _("NT_FPREGS (floating point registers)");
15069       case NT_PSINFO:
15070         return _("NT_PSINFO (psinfo structure)");
15071       case NT_LWPSTATUS:
15072         return _("NT_LWPSTATUS (lwpstatus_t structure)");
15073       case NT_LWPSINFO:
15074         return _("NT_LWPSINFO (lwpsinfo_t structure)");
15075       case NT_WIN32PSTATUS:
15076         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15077       case NT_SIGINFO:
15078         return _("NT_SIGINFO (siginfo_t data)");
15079       case NT_FILE:
15080         return _("NT_FILE (mapped files)");
15081       default:
15082         break;
15083       }
15084   else
15085     switch (e_type)
15086       {
15087       case NT_VERSION:
15088         return _("NT_VERSION (version)");
15089       case NT_ARCH:
15090         return _("NT_ARCH (architecture)");
15091       default:
15092         break;
15093       }
15094
15095   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15096   return buff;
15097 }
15098
15099 static int
15100 print_core_note (Elf_Internal_Note *pnote)
15101 {
15102   unsigned int addr_size = is_32bit_elf ? 4 : 8;
15103   bfd_vma count, page_size;
15104   unsigned char *descdata, *filenames, *descend;
15105
15106   if (pnote->type != NT_FILE)
15107     return 1;
15108
15109 #ifndef BFD64
15110   if (!is_32bit_elf)
15111     {
15112       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
15113       /* Still "successful".  */
15114       return 1;
15115     }
15116 #endif
15117
15118   if (pnote->descsz < 2 * addr_size)
15119     {
15120       printf (_("    Malformed note - too short for header\n"));
15121       return 0;
15122     }
15123
15124   descdata = (unsigned char *) pnote->descdata;
15125   descend = descdata + pnote->descsz;
15126
15127   if (descdata[pnote->descsz - 1] != '\0')
15128     {
15129       printf (_("    Malformed note - does not end with \\0\n"));
15130       return 0;
15131     }
15132
15133   count = byte_get (descdata, addr_size);
15134   descdata += addr_size;
15135
15136   page_size = byte_get (descdata, addr_size);
15137   descdata += addr_size;
15138
15139   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15140     {
15141       printf (_("    Malformed note - too short for supplied file count\n"));
15142       return 0;
15143     }
15144
15145   printf (_("    Page size: "));
15146   print_vma (page_size, DEC);
15147   printf ("\n");
15148
15149   printf (_("    %*s%*s%*s\n"),
15150           (int) (2 + 2 * addr_size), _("Start"),
15151           (int) (4 + 2 * addr_size), _("End"),
15152           (int) (4 + 2 * addr_size), _("Page Offset"));
15153   filenames = descdata + count * 3 * addr_size;
15154   while (count-- > 0)
15155     {
15156       bfd_vma start, end, file_ofs;
15157
15158       if (filenames == descend)
15159         {
15160           printf (_("    Malformed note - filenames end too early\n"));
15161           return 0;
15162         }
15163
15164       start = byte_get (descdata, addr_size);
15165       descdata += addr_size;
15166       end = byte_get (descdata, addr_size);
15167       descdata += addr_size;
15168       file_ofs = byte_get (descdata, addr_size);
15169       descdata += addr_size;
15170
15171       printf ("    ");
15172       print_vma (start, FULL_HEX);
15173       printf ("  ");
15174       print_vma (end, FULL_HEX);
15175       printf ("  ");
15176       print_vma (file_ofs, FULL_HEX);
15177       printf ("\n        %s\n", filenames);
15178
15179       filenames += 1 + strlen ((char *) filenames);
15180     }
15181
15182   return 1;
15183 }
15184
15185 static const char *
15186 get_gnu_elf_note_type (unsigned e_type)
15187 {
15188   static char buff[64];
15189
15190   switch (e_type)
15191     {
15192     case NT_GNU_ABI_TAG:
15193       return _("NT_GNU_ABI_TAG (ABI version tag)");
15194     case NT_GNU_HWCAP:
15195       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15196     case NT_GNU_BUILD_ID:
15197       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15198     case NT_GNU_GOLD_VERSION:
15199       return _("NT_GNU_GOLD_VERSION (gold version)");
15200     default:
15201       break;
15202     }
15203
15204   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15205   return buff;
15206 }
15207
15208 static int
15209 print_gnu_note (Elf_Internal_Note *pnote)
15210 {
15211   switch (pnote->type)
15212     {
15213     case NT_GNU_BUILD_ID:
15214       {
15215         unsigned long i;
15216
15217         printf (_("    Build ID: "));
15218         for (i = 0; i < pnote->descsz; ++i)
15219           printf ("%02x", pnote->descdata[i] & 0xff);
15220         printf ("\n");
15221       }
15222       break;
15223
15224     case NT_GNU_ABI_TAG:
15225       {
15226         unsigned long os, major, minor, subminor;
15227         const char *osname;
15228
15229         /* PR 17531: file: 030-599401-0.004.  */
15230         if (pnote->descsz < 16)
15231           {
15232             printf (_("    <corrupt GNU_ABI_TAG>\n"));
15233             break;
15234           }
15235
15236         os = byte_get ((unsigned char *) pnote->descdata, 4);
15237         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15238         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15239         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15240
15241         switch (os)
15242           {
15243           case GNU_ABI_TAG_LINUX:
15244             osname = "Linux";
15245             break;
15246           case GNU_ABI_TAG_HURD:
15247             osname = "Hurd";
15248             break;
15249           case GNU_ABI_TAG_SOLARIS:
15250             osname = "Solaris";
15251             break;
15252           case GNU_ABI_TAG_FREEBSD:
15253             osname = "FreeBSD";
15254             break;
15255           case GNU_ABI_TAG_NETBSD:
15256             osname = "NetBSD";
15257             break;
15258           case GNU_ABI_TAG_SYLLABLE:
15259             osname = "Syllable";
15260             break;
15261           case GNU_ABI_TAG_NACL:
15262             osname = "NaCl";
15263             break;
15264           default:
15265             osname = "Unknown";
15266             break;
15267           }
15268
15269         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15270                 major, minor, subminor);
15271       }
15272       break;
15273
15274     case NT_GNU_GOLD_VERSION:
15275       {
15276         unsigned long i;
15277
15278         printf (_("    Version: "));
15279         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15280           printf ("%c", pnote->descdata[i]);
15281         printf ("\n");
15282       }
15283       break;
15284     }
15285
15286   return 1;
15287 }
15288
15289 static const char *
15290 get_v850_elf_note_type (enum v850_notes n_type)
15291 {
15292   static char buff[64];
15293
15294   switch (n_type)
15295     {
15296     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
15297     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
15298     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
15299     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
15300     case V850_NOTE_CACHE_INFO: return _("Use of cache");
15301     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
15302     default:
15303       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15304       return buff;
15305     }
15306 }
15307
15308 static int
15309 print_v850_note (Elf_Internal_Note * pnote)
15310 {
15311   unsigned int val;
15312
15313   if (pnote->descsz != 4)
15314     return 0;
15315   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15316
15317   if (val == 0)
15318     {
15319       printf (_("not set\n"));
15320       return 1;
15321     }
15322
15323   switch (pnote->type)
15324     {
15325     case V850_NOTE_ALIGNMENT:
15326       switch (val)
15327         {
15328         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15329         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15330         }
15331       break;
15332
15333     case V850_NOTE_DATA_SIZE:
15334       switch (val)
15335         {
15336         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15337         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15338         }
15339       break;
15340
15341     case V850_NOTE_FPU_INFO:
15342       switch (val)
15343         {
15344         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15345         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15346         }
15347       break;
15348
15349     case V850_NOTE_MMU_INFO:
15350     case V850_NOTE_CACHE_INFO:
15351     case V850_NOTE_SIMD_INFO:
15352       if (val == EF_RH850_SIMD)
15353         {
15354           printf (_("yes\n"));
15355           return 1;
15356         }
15357       break;
15358
15359     default:
15360       /* An 'unknown note type' message will already have been displayed.  */
15361       break;
15362     }
15363
15364   printf (_("unknown value: %x\n"), val);
15365   return 0;
15366 }
15367
15368 static const char *
15369 get_netbsd_elfcore_note_type (unsigned e_type)
15370 {
15371   static char buff[64];
15372
15373   if (e_type == NT_NETBSDCORE_PROCINFO)
15374     {
15375       /* NetBSD core "procinfo" structure.  */
15376       return _("NetBSD procinfo structure");
15377     }
15378
15379   /* As of Jan 2002 there are no other machine-independent notes
15380      defined for NetBSD core files.  If the note type is less
15381      than the start of the machine-dependent note types, we don't
15382      understand it.  */
15383
15384   if (e_type < NT_NETBSDCORE_FIRSTMACH)
15385     {
15386       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15387       return buff;
15388     }
15389
15390   switch (elf_header.e_machine)
15391     {
15392     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15393        and PT_GETFPREGS == mach+2.  */
15394
15395     case EM_OLD_ALPHA:
15396     case EM_ALPHA:
15397     case EM_SPARC:
15398     case EM_SPARC32PLUS:
15399     case EM_SPARCV9:
15400       switch (e_type)
15401         {
15402         case NT_NETBSDCORE_FIRSTMACH + 0:
15403           return _("PT_GETREGS (reg structure)");
15404         case NT_NETBSDCORE_FIRSTMACH + 2:
15405           return _("PT_GETFPREGS (fpreg structure)");
15406         default:
15407           break;
15408         }
15409       break;
15410
15411     /* On all other arch's, PT_GETREGS == mach+1 and
15412        PT_GETFPREGS == mach+3.  */
15413     default:
15414       switch (e_type)
15415         {
15416         case NT_NETBSDCORE_FIRSTMACH + 1:
15417           return _("PT_GETREGS (reg structure)");
15418         case NT_NETBSDCORE_FIRSTMACH + 3:
15419           return _("PT_GETFPREGS (fpreg structure)");
15420         default:
15421           break;
15422         }
15423     }
15424
15425   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15426             e_type - NT_NETBSDCORE_FIRSTMACH);
15427   return buff;
15428 }
15429
15430 static const char *
15431 get_stapsdt_note_type (unsigned e_type)
15432 {
15433   static char buff[64];
15434
15435   switch (e_type)
15436     {
15437     case NT_STAPSDT:
15438       return _("NT_STAPSDT (SystemTap probe descriptors)");
15439
15440     default:
15441       break;
15442     }
15443
15444   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15445   return buff;
15446 }
15447
15448 static int
15449 print_stapsdt_note (Elf_Internal_Note *pnote)
15450 {
15451   int addr_size = is_32bit_elf ? 4 : 8;
15452   char *data = pnote->descdata;
15453   char *data_end = pnote->descdata + pnote->descsz;
15454   bfd_vma pc, base_addr, semaphore;
15455   char *provider, *probe, *arg_fmt;
15456
15457   pc = byte_get ((unsigned char *) data, addr_size);
15458   data += addr_size;
15459   base_addr = byte_get ((unsigned char *) data, addr_size);
15460   data += addr_size;
15461   semaphore = byte_get ((unsigned char *) data, addr_size);
15462   data += addr_size;
15463
15464   provider = data;
15465   data += strlen (data) + 1;
15466   probe = data;
15467   data += strlen (data) + 1;
15468   arg_fmt = data;
15469   data += strlen (data) + 1;
15470
15471   printf (_("    Provider: %s\n"), provider);
15472   printf (_("    Name: %s\n"), probe);
15473   printf (_("    Location: "));
15474   print_vma (pc, FULL_HEX);
15475   printf (_(", Base: "));
15476   print_vma (base_addr, FULL_HEX);
15477   printf (_(", Semaphore: "));
15478   print_vma (semaphore, FULL_HEX);
15479   printf ("\n");
15480   printf (_("    Arguments: %s\n"), arg_fmt);
15481
15482   return data == data_end;
15483 }
15484
15485 static const char *
15486 get_ia64_vms_note_type (unsigned e_type)
15487 {
15488   static char buff[64];
15489
15490   switch (e_type)
15491     {
15492     case NT_VMS_MHD:
15493       return _("NT_VMS_MHD (module header)");
15494     case NT_VMS_LNM:
15495       return _("NT_VMS_LNM (language name)");
15496     case NT_VMS_SRC:
15497       return _("NT_VMS_SRC (source files)");
15498     case NT_VMS_TITLE:
15499       return "NT_VMS_TITLE";
15500     case NT_VMS_EIDC:
15501       return _("NT_VMS_EIDC (consistency check)");
15502     case NT_VMS_FPMODE:
15503       return _("NT_VMS_FPMODE (FP mode)");
15504     case NT_VMS_LINKTIME:
15505       return "NT_VMS_LINKTIME";
15506     case NT_VMS_IMGNAM:
15507       return _("NT_VMS_IMGNAM (image name)");
15508     case NT_VMS_IMGID:
15509       return _("NT_VMS_IMGID (image id)");
15510     case NT_VMS_LINKID:
15511       return _("NT_VMS_LINKID (link id)");
15512     case NT_VMS_IMGBID:
15513       return _("NT_VMS_IMGBID (build id)");
15514     case NT_VMS_GSTNAM:
15515       return _("NT_VMS_GSTNAM (sym table name)");
15516     case NT_VMS_ORIG_DYN:
15517       return "NT_VMS_ORIG_DYN";
15518     case NT_VMS_PATCHTIME:
15519       return "NT_VMS_PATCHTIME";
15520     default:
15521       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15522       return buff;
15523     }
15524 }
15525
15526 static int
15527 print_ia64_vms_note (Elf_Internal_Note * pnote)
15528 {
15529   switch (pnote->type)
15530     {
15531     case NT_VMS_MHD:
15532       if (pnote->descsz > 36)
15533         {
15534           size_t l = strlen (pnote->descdata + 34);
15535           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
15536           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
15537           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
15538           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
15539         }
15540       else
15541         printf (_("    Invalid size\n"));
15542       break;
15543     case NT_VMS_LNM:
15544       printf (_("   Language: %s\n"), pnote->descdata);
15545       break;
15546 #ifdef BFD64
15547     case NT_VMS_FPMODE:
15548       printf (_("   Floating Point mode: "));
15549       printf ("0x%016" BFD_VMA_FMT "x\n",
15550               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15551       break;
15552     case NT_VMS_LINKTIME:
15553       printf (_("   Link time: "));
15554       print_vms_time
15555         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15556       printf ("\n");
15557       break;
15558     case NT_VMS_PATCHTIME:
15559       printf (_("   Patch time: "));
15560       print_vms_time
15561         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15562       printf ("\n");
15563       break;
15564     case NT_VMS_ORIG_DYN:
15565       printf (_("   Major id: %u,  minor id: %u\n"),
15566               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15567               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15568       printf (_("   Last modified  : "));
15569       print_vms_time
15570         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15571       printf (_("\n   Link flags  : "));
15572       printf ("0x%016" BFD_VMA_FMT "x\n",
15573               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15574       printf (_("   Header flags: 0x%08x\n"),
15575               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15576       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
15577       break;
15578 #endif
15579     case NT_VMS_IMGNAM:
15580       printf (_("    Image name: %s\n"), pnote->descdata);
15581       break;
15582     case NT_VMS_GSTNAM:
15583       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
15584       break;
15585     case NT_VMS_IMGID:
15586       printf (_("    Image id: %s\n"), pnote->descdata);
15587       break;
15588     case NT_VMS_LINKID:
15589       printf (_("    Linker id: %s\n"), pnote->descdata);
15590       break;
15591     default:
15592       break;
15593     }
15594   return 1;
15595 }
15596
15597 /* Note that by the ELF standard, the name field is already null byte
15598    terminated, and namesz includes the terminating null byte.
15599    I.E. the value of namesz for the name "FSF" is 4.
15600
15601    If the value of namesz is zero, there is no name present.  */
15602 static int
15603 process_note (Elf_Internal_Note * pnote)
15604 {
15605   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15606   const char * nt;
15607
15608   if (pnote->namesz == 0)
15609     /* If there is no note name, then use the default set of
15610        note type strings.  */
15611     nt = get_note_type (pnote->type);
15612
15613   else if (const_strneq (pnote->namedata, "GNU"))
15614     /* GNU-specific object file notes.  */
15615     nt = get_gnu_elf_note_type (pnote->type);
15616
15617   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15618     /* NetBSD-specific core file notes.  */
15619     nt = get_netbsd_elfcore_note_type (pnote->type);
15620
15621   else if (strneq (pnote->namedata, "SPU/", 4))
15622     {
15623       /* SPU-specific core file notes.  */
15624       nt = pnote->namedata + 4;
15625       name = "SPU";
15626     }
15627
15628   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15629     /* VMS/ia64-specific file notes.  */
15630     nt = get_ia64_vms_note_type (pnote->type);
15631
15632   else if (const_strneq (pnote->namedata, "stapsdt"))
15633     nt = get_stapsdt_note_type (pnote->type);
15634
15635   else
15636     /* Don't recognize this note name; just use the default set of
15637        note type strings.  */
15638     nt = get_note_type (pnote->type);
15639
15640   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15641
15642   if (const_strneq (pnote->namedata, "IPF/VMS"))
15643     return print_ia64_vms_note (pnote);
15644   else if (const_strneq (pnote->namedata, "GNU"))
15645     return print_gnu_note (pnote);
15646   else if (const_strneq (pnote->namedata, "stapsdt"))
15647     return print_stapsdt_note (pnote);
15648   else if (const_strneq (pnote->namedata, "CORE"))
15649     return print_core_note (pnote);
15650   else
15651     return 1;
15652 }
15653
15654
15655 static int
15656 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15657 {
15658   Elf_External_Note * pnotes;
15659   Elf_External_Note * external;
15660   char * end;
15661   int res = 1;
15662
15663   if (length <= 0)
15664     return 0;
15665
15666   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15667                                            _("notes"));
15668   if (pnotes == NULL)
15669     return 0;
15670
15671   external = pnotes;
15672
15673   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15674           (unsigned long) offset, (unsigned long) length);
15675   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15676
15677   end = (char *) pnotes + length;
15678   while ((char *) external < end)
15679     {
15680       Elf_Internal_Note inote;
15681       size_t min_notesz;
15682       char *next;
15683       char * temp = NULL;
15684       size_t data_remaining = end - (char *) external;
15685
15686       if (!is_ia64_vms ())
15687         {
15688           /* PR binutils/15191
15689              Make sure that there is enough data to read.  */
15690           min_notesz = offsetof (Elf_External_Note, name);
15691           if (data_remaining < min_notesz)
15692             {
15693               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15694                     (int) data_remaining);
15695               break;
15696             }
15697           inote.type     = BYTE_GET (external->type);
15698           inote.namesz   = BYTE_GET (external->namesz);
15699           inote.namedata = external->name;
15700           inote.descsz   = BYTE_GET (external->descsz);
15701           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15702           /* PR 17531: file: 3443835e.  */
15703           if (inote.descdata < (char *) pnotes || inote.descdata > end)
15704             {
15705               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15706               inote.descdata = inote.namedata;
15707               inote.namesz   = 0;
15708             }
15709
15710           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15711           next = inote.descdata + align_power (inote.descsz, 2);
15712         }
15713       else
15714         {
15715           Elf64_External_VMS_Note *vms_external;
15716
15717           /* PR binutils/15191
15718              Make sure that there is enough data to read.  */
15719           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15720           if (data_remaining < min_notesz)
15721             {
15722               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15723                     (int) data_remaining);
15724               break;
15725             }
15726
15727           vms_external = (Elf64_External_VMS_Note *) external;
15728           inote.type     = BYTE_GET (vms_external->type);
15729           inote.namesz   = BYTE_GET (vms_external->namesz);
15730           inote.namedata = vms_external->name;
15731           inote.descsz   = BYTE_GET (vms_external->descsz);
15732           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15733           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15734           next = inote.descdata + align_power (inote.descsz, 3);
15735         }
15736
15737       if (inote.descdata < (char *) external + min_notesz
15738           || next < (char *) external + min_notesz
15739           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15740           || inote.namedata + inote.namesz < inote.namedata
15741           || inote.descdata + inote.descsz < inote.descdata
15742           || data_remaining < (size_t)(next - (char *) external))
15743         {
15744           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15745                 (unsigned long) ((char *) external - (char *) pnotes));
15746           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15747                 inote.type, inote.namesz, inote.descsz);
15748           break;
15749         }
15750
15751       external = (Elf_External_Note *) next;
15752
15753       /* Verify that name is null terminated.  It appears that at least
15754          one version of Linux (RedHat 6.0) generates corefiles that don't
15755          comply with the ELF spec by failing to include the null byte in
15756          namesz.  */
15757       if (inote.namedata[inote.namesz - 1] != '\0')
15758         {
15759           temp = (char *) malloc (inote.namesz + 1);
15760           if (temp == NULL)
15761             {
15762               error (_("Out of memory allocating space for inote name\n"));
15763               res = 0;
15764               break;
15765             }
15766
15767           strncpy (temp, inote.namedata, inote.namesz);
15768           temp[inote.namesz] = 0;
15769
15770           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15771           inote.namedata = temp;
15772         }
15773
15774       res &= process_note (& inote);
15775
15776       if (temp != NULL)
15777         {
15778           free (temp);
15779           temp = NULL;
15780         }
15781     }
15782
15783   free (pnotes);
15784
15785   return res;
15786 }
15787
15788 static int
15789 process_corefile_note_segments (FILE * file)
15790 {
15791   Elf_Internal_Phdr * segment;
15792   unsigned int i;
15793   int res = 1;
15794
15795   if (! get_program_headers (file))
15796       return 0;
15797
15798   for (i = 0, segment = program_headers;
15799        i < elf_header.e_phnum;
15800        i++, segment++)
15801     {
15802       if (segment->p_type == PT_NOTE)
15803         res &= process_corefile_note_segment (file,
15804                                               (bfd_vma) segment->p_offset,
15805                                               (bfd_vma) segment->p_filesz);
15806     }
15807
15808   return res;
15809 }
15810
15811 static int
15812 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15813 {
15814   Elf_External_Note * pnotes;
15815   Elf_External_Note * external;
15816   char * end;
15817   int res = 1;
15818
15819   if (length <= 0)
15820     return 0;
15821
15822   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15823                                            _("v850 notes"));
15824   if (pnotes == NULL)
15825     return 0;
15826
15827   external = pnotes;
15828   end = (char*) pnotes + length;
15829
15830   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15831           (unsigned long) offset, (unsigned long) length);
15832
15833   while ((char *) external + sizeof (Elf_External_Note) < end)
15834     {
15835       Elf_External_Note * next;
15836       Elf_Internal_Note inote;
15837
15838       inote.type     = BYTE_GET (external->type);
15839       inote.namesz   = BYTE_GET (external->namesz);
15840       inote.namedata = external->name;
15841       inote.descsz   = BYTE_GET (external->descsz);
15842       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15843       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15844
15845       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15846         {
15847           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15848           inote.descdata = inote.namedata;
15849           inote.namesz   = 0;
15850         }
15851
15852       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15853
15854       if (   ((char *) next > end)
15855           || ((char *) next <  (char *) pnotes))
15856         {
15857           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15858                 (unsigned long) ((char *) external - (char *) pnotes));
15859           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15860                 inote.type, inote.namesz, inote.descsz);
15861           break;
15862         }
15863
15864       external = next;
15865
15866       /* Prevent out-of-bounds indexing.  */
15867       if (   inote.namedata + inote.namesz > end
15868           || inote.namedata + inote.namesz < inote.namedata)
15869         {
15870           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15871                 (unsigned long) ((char *) external - (char *) pnotes));
15872           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15873                 inote.type, inote.namesz, inote.descsz);
15874           break;
15875         }
15876
15877       printf ("  %s: ", get_v850_elf_note_type (inote.type));
15878
15879       if (! print_v850_note (& inote))
15880         {
15881           res = 0;
15882           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15883                   inote.namesz, inote.descsz);
15884         }
15885     }
15886
15887   free (pnotes);
15888
15889   return res;
15890 }
15891
15892 static int
15893 process_note_sections (FILE * file)
15894 {
15895   Elf_Internal_Shdr * section;
15896   unsigned long i;
15897   int n = 0;
15898   int res = 1;
15899
15900   for (i = 0, section = section_headers;
15901        i < elf_header.e_shnum && section != NULL;
15902        i++, section++)
15903     {
15904       if (section->sh_type == SHT_NOTE)
15905         {
15906           res &= process_corefile_note_segment (file,
15907                                                 (bfd_vma) section->sh_offset,
15908                                                 (bfd_vma) section->sh_size);
15909           n++;
15910         }
15911
15912       if ((   elf_header.e_machine == EM_V800
15913            || elf_header.e_machine == EM_V850
15914            || elf_header.e_machine == EM_CYGNUS_V850)
15915           && section->sh_type == SHT_RENESAS_INFO)
15916         {
15917           res &= process_v850_notes (file,
15918                                      (bfd_vma) section->sh_offset,
15919                                      (bfd_vma) section->sh_size);
15920           n++;
15921         }
15922     }
15923
15924   if (n == 0)
15925     /* Try processing NOTE segments instead.  */
15926     return process_corefile_note_segments (file);
15927
15928   return res;
15929 }
15930
15931 static int
15932 process_notes (FILE * file)
15933 {
15934   /* If we have not been asked to display the notes then do nothing.  */
15935   if (! do_notes)
15936     return 1;
15937
15938   if (elf_header.e_type != ET_CORE)
15939     return process_note_sections (file);
15940
15941   /* No program headers means no NOTE segment.  */
15942   if (elf_header.e_phnum > 0)
15943     return process_corefile_note_segments (file);
15944
15945   printf (_("No note segments present in the core file.\n"));
15946   return 1;
15947 }
15948
15949 static int
15950 process_arch_specific (FILE * file)
15951 {
15952   if (! do_arch)
15953     return 1;
15954
15955   switch (elf_header.e_machine)
15956     {
15957     case EM_ARM:
15958       return process_arm_specific (file);
15959     case EM_MIPS:
15960     case EM_MIPS_RS3_LE:
15961       return process_mips_specific (file);
15962       break;
15963     case EM_NDS32:
15964       return process_nds32_specific (file);
15965       break;
15966     case EM_PPC:
15967       return process_power_specific (file);
15968       break;
15969     case EM_S390:
15970     case EM_S390_OLD:
15971       return process_s390_specific (file);
15972       break;
15973     case EM_SPARC:
15974     case EM_SPARC32PLUS:
15975     case EM_SPARCV9:
15976       return process_sparc_specific (file);
15977       break;
15978     case EM_TI_C6000:
15979       return process_tic6x_specific (file);
15980       break;
15981     case EM_MSP430:
15982       return process_msp430x_specific (file);
15983     default:
15984       break;
15985     }
15986   return 1;
15987 }
15988
15989 static int
15990 get_file_header (FILE * file)
15991 {
15992   /* Read in the identity array.  */
15993   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15994     return 0;
15995
15996   /* Determine how to read the rest of the header.  */
15997   switch (elf_header.e_ident[EI_DATA])
15998     {
15999     default: /* fall through */
16000     case ELFDATANONE: /* fall through */
16001     case ELFDATA2LSB:
16002       byte_get = byte_get_little_endian;
16003       byte_put = byte_put_little_endian;
16004       break;
16005     case ELFDATA2MSB:
16006       byte_get = byte_get_big_endian;
16007       byte_put = byte_put_big_endian;
16008       break;
16009     }
16010
16011   /* For now we only support 32 bit and 64 bit ELF files.  */
16012   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
16013
16014   /* Read in the rest of the header.  */
16015   if (is_32bit_elf)
16016     {
16017       Elf32_External_Ehdr ehdr32;
16018
16019       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16020         return 0;
16021
16022       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
16023       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
16024       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
16025       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
16026       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
16027       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
16028       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
16029       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
16030       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16031       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
16032       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16033       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
16034       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
16035     }
16036   else
16037     {
16038       Elf64_External_Ehdr ehdr64;
16039
16040       /* If we have been compiled with sizeof (bfd_vma) == 4, then
16041          we will not be able to cope with the 64bit data found in
16042          64 ELF files.  Detect this now and abort before we start
16043          overwriting things.  */
16044       if (sizeof (bfd_vma) < 8)
16045         {
16046           error (_("This instance of readelf has been built without support for a\n\
16047 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16048           return 0;
16049         }
16050
16051       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16052         return 0;
16053
16054       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
16055       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
16056       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
16057       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
16058       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
16059       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
16060       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
16061       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
16062       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16063       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
16064       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16065       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
16066       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
16067     }
16068
16069   if (elf_header.e_shoff)
16070     {
16071       /* There may be some extensions in the first section header.  Don't
16072          bomb if we can't read it.  */
16073       if (is_32bit_elf)
16074         get_32bit_section_headers (file, TRUE);
16075       else
16076         get_64bit_section_headers (file, TRUE);
16077     }
16078
16079   return 1;
16080 }
16081
16082 /* Process one ELF object file according to the command line options.
16083    This file may actually be stored in an archive.  The file is
16084    positioned at the start of the ELF object.  */
16085
16086 static int
16087 process_object (char * file_name, FILE * file)
16088 {
16089   unsigned int i;
16090
16091   if (! get_file_header (file))
16092     {
16093       error (_("%s: Failed to read file header\n"), file_name);
16094       return 1;
16095     }
16096
16097   /* Initialise per file variables.  */
16098   for (i = ARRAY_SIZE (version_info); i--;)
16099     version_info[i] = 0;
16100
16101   for (i = ARRAY_SIZE (dynamic_info); i--;)
16102     dynamic_info[i] = 0;
16103   dynamic_info_DT_GNU_HASH = 0;
16104
16105   /* Process the file.  */
16106   if (show_name)
16107     printf (_("\nFile: %s\n"), file_name);
16108
16109   /* Initialise the dump_sects array from the cmdline_dump_sects array.
16110      Note we do this even if cmdline_dump_sects is empty because we
16111      must make sure that the dump_sets array is zeroed out before each
16112      object file is processed.  */
16113   if (num_dump_sects > num_cmdline_dump_sects)
16114     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
16115
16116   if (num_cmdline_dump_sects > 0)
16117     {
16118       if (num_dump_sects == 0)
16119         /* A sneaky way of allocating the dump_sects array.  */
16120         request_dump_bynumber (num_cmdline_dump_sects, 0);
16121
16122       assert (num_dump_sects >= num_cmdline_dump_sects);
16123       memcpy (dump_sects, cmdline_dump_sects,
16124               num_cmdline_dump_sects * sizeof (* dump_sects));
16125     }
16126
16127   if (! process_file_header ())
16128     return 1;
16129
16130   if (! process_section_headers (file))
16131     {
16132       /* Without loaded section headers we cannot process lots of
16133          things.  */
16134       do_unwind = do_version = do_dump = do_arch = 0;
16135
16136       if (! do_using_dynamic)
16137         do_syms = do_dyn_syms = do_reloc = 0;
16138     }
16139
16140   if (! process_section_groups (file))
16141     {
16142       /* Without loaded section groups we cannot process unwind.  */
16143       do_unwind = 0;
16144     }
16145
16146   if (process_program_headers (file))
16147     process_dynamic_section (file);
16148
16149   process_relocs (file);
16150
16151   process_unwind (file);
16152
16153   process_symbol_table (file);
16154
16155   process_syminfo (file);
16156
16157   process_version_sections (file);
16158
16159   process_section_contents (file);
16160
16161   process_notes (file);
16162
16163   process_gnu_liblist (file);
16164
16165   process_arch_specific (file);
16166
16167   if (program_headers)
16168     {
16169       free (program_headers);
16170       program_headers = NULL;
16171     }
16172
16173   if (section_headers)
16174     {
16175       free (section_headers);
16176       section_headers = NULL;
16177     }
16178
16179   if (string_table)
16180     {
16181       free (string_table);
16182       string_table = NULL;
16183       string_table_length = 0;
16184     }
16185
16186   if (dynamic_strings)
16187     {
16188       free (dynamic_strings);
16189       dynamic_strings = NULL;
16190       dynamic_strings_length = 0;
16191     }
16192
16193   if (dynamic_symbols)
16194     {
16195       free (dynamic_symbols);
16196       dynamic_symbols = NULL;
16197       num_dynamic_syms = 0;
16198     }
16199
16200   if (dynamic_syminfo)
16201     {
16202       free (dynamic_syminfo);
16203       dynamic_syminfo = NULL;
16204     }
16205
16206   if (dynamic_section)
16207     {
16208       free (dynamic_section);
16209       dynamic_section = NULL;
16210     }
16211
16212   if (section_headers_groups)
16213     {
16214       free (section_headers_groups);
16215       section_headers_groups = NULL;
16216     }
16217
16218   if (section_groups)
16219     {
16220       struct group_list * g;
16221       struct group_list * next;
16222
16223       for (i = 0; i < group_count; i++)
16224         {
16225           for (g = section_groups [i].root; g != NULL; g = next)
16226             {
16227               next = g->next;
16228               free (g);
16229             }
16230         }
16231
16232       free (section_groups);
16233       section_groups = NULL;
16234     }
16235
16236   free_debug_memory ();
16237
16238   return 0;
16239 }
16240
16241 /* Process an ELF archive.
16242    On entry the file is positioned just after the ARMAG string.  */
16243
16244 static int
16245 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16246 {
16247   struct archive_info arch;
16248   struct archive_info nested_arch;
16249   size_t got;
16250   int ret;
16251
16252   show_name = 1;
16253
16254   /* The ARCH structure is used to hold information about this archive.  */
16255   arch.file_name = NULL;
16256   arch.file = NULL;
16257   arch.index_array = NULL;
16258   arch.sym_table = NULL;
16259   arch.longnames = NULL;
16260
16261   /* The NESTED_ARCH structure is used as a single-item cache of information
16262      about a nested archive (when members of a thin archive reside within
16263      another regular archive file).  */
16264   nested_arch.file_name = NULL;
16265   nested_arch.file = NULL;
16266   nested_arch.index_array = NULL;
16267   nested_arch.sym_table = NULL;
16268   nested_arch.longnames = NULL;
16269
16270   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16271     {
16272       ret = 1;
16273       goto out;
16274     }
16275
16276   if (do_archive_index)
16277     {
16278       if (arch.sym_table == NULL)
16279         error (_("%s: unable to dump the index as none was found\n"), file_name);
16280       else
16281         {
16282           unsigned long i, l;
16283           unsigned long current_pos;
16284
16285           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16286                   file_name, (unsigned long) arch.index_num, arch.sym_size);
16287           current_pos = ftell (file);
16288
16289           for (i = l = 0; i < arch.index_num; i++)
16290             {
16291               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16292                 {
16293                   char * member_name;
16294
16295                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16296
16297                   if (member_name != NULL)
16298                     {
16299                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16300
16301                       if (qualified_name != NULL)
16302                         {
16303                           printf (_("Contents of binary %s at offset "), qualified_name);
16304                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
16305                           putchar ('\n');
16306                           free (qualified_name);
16307                         }
16308                     }
16309                 }
16310
16311               if (l >= arch.sym_size)
16312                 {
16313                   error (_("%s: end of the symbol table reached before the end of the index\n"),
16314                          file_name);
16315                   break;
16316                 }
16317               /* PR 17531: file: 0b6630b2.  */
16318               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16319               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16320             }
16321
16322           if (arch.uses_64bit_indicies)
16323             l = (l + 7) & ~ 7;
16324           else
16325             l += l & 1;
16326
16327           if (l < arch.sym_size)
16328             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16329                    file_name, arch.sym_size - l);
16330
16331           if (fseek (file, current_pos, SEEK_SET) != 0)
16332             {
16333               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16334               ret = 1;
16335               goto out;
16336             }
16337         }
16338
16339       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16340           && !do_segments && !do_header && !do_dump && !do_version
16341           && !do_histogram && !do_debugging && !do_arch && !do_notes
16342           && !do_section_groups && !do_dyn_syms)
16343         {
16344           ret = 0; /* Archive index only.  */
16345           goto out;
16346         }
16347     }
16348
16349   ret = 0;
16350
16351   while (1)
16352     {
16353       char * name;
16354       size_t namelen;
16355       char * qualified_name;
16356
16357       /* Read the next archive header.  */
16358       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16359         {
16360           error (_("%s: failed to seek to next archive header\n"), file_name);
16361           return 1;
16362         }
16363       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16364       if (got != sizeof arch.arhdr)
16365         {
16366           if (got == 0)
16367             break;
16368           error (_("%s: failed to read archive header\n"), file_name);
16369           ret = 1;
16370           break;
16371         }
16372       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16373         {
16374           error (_("%s: did not find a valid archive header\n"), arch.file_name);
16375           ret = 1;
16376           break;
16377         }
16378
16379       arch.next_arhdr_offset += sizeof arch.arhdr;
16380
16381       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16382       if (archive_file_size & 01)
16383         ++archive_file_size;
16384
16385       name = get_archive_member_name (&arch, &nested_arch);
16386       if (name == NULL)
16387         {
16388           error (_("%s: bad archive file name\n"), file_name);
16389           ret = 1;
16390           break;
16391         }
16392       namelen = strlen (name);
16393
16394       qualified_name = make_qualified_name (&arch, &nested_arch, name);
16395       if (qualified_name == NULL)
16396         {
16397           error (_("%s: bad archive file name\n"), file_name);
16398           ret = 1;
16399           break;
16400         }
16401
16402       if (is_thin_archive && arch.nested_member_origin == 0)
16403         {
16404           /* This is a proxy for an external member of a thin archive.  */
16405           FILE * member_file;
16406           char * member_file_name = adjust_relative_path (file_name, name, namelen);
16407           if (member_file_name == NULL)
16408             {
16409               ret = 1;
16410               break;
16411             }
16412
16413           member_file = fopen (member_file_name, "rb");
16414           if (member_file == NULL)
16415             {
16416               error (_("Input file '%s' is not readable.\n"), member_file_name);
16417               free (member_file_name);
16418               ret = 1;
16419               break;
16420             }
16421
16422           archive_file_offset = arch.nested_member_origin;
16423
16424           ret |= process_object (qualified_name, member_file);
16425
16426           fclose (member_file);
16427           free (member_file_name);
16428         }
16429       else if (is_thin_archive)
16430         {
16431           /* PR 15140: Allow for corrupt thin archives.  */
16432           if (nested_arch.file == NULL)
16433             {
16434               error (_("%s: contains corrupt thin archive: %s\n"),
16435                      file_name, name);
16436               ret = 1;
16437               break;
16438             }
16439
16440           /* This is a proxy for a member of a nested archive.  */
16441           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16442
16443           /* The nested archive file will have been opened and setup by
16444              get_archive_member_name.  */
16445           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16446             {
16447               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16448               ret = 1;
16449               break;
16450             }
16451
16452           ret |= process_object (qualified_name, nested_arch.file);
16453         }
16454       else
16455         {
16456           archive_file_offset = arch.next_arhdr_offset;
16457           arch.next_arhdr_offset += archive_file_size;
16458
16459           ret |= process_object (qualified_name, file);
16460         }
16461
16462       if (dump_sects != NULL)
16463         {
16464           free (dump_sects);
16465           dump_sects = NULL;
16466           num_dump_sects = 0;
16467         }
16468
16469       free (qualified_name);
16470     }
16471
16472  out:
16473   if (nested_arch.file != NULL)
16474     fclose (nested_arch.file);
16475   release_archive (&nested_arch);
16476   release_archive (&arch);
16477
16478   return ret;
16479 }
16480
16481 static int
16482 process_file (char * file_name)
16483 {
16484   FILE * file;
16485   struct stat statbuf;
16486   char armag[SARMAG];
16487   int ret;
16488
16489   if (stat (file_name, &statbuf) < 0)
16490     {
16491       if (errno == ENOENT)
16492         error (_("'%s': No such file\n"), file_name);
16493       else
16494         error (_("Could not locate '%s'.  System error message: %s\n"),
16495                file_name, strerror (errno));
16496       return 1;
16497     }
16498
16499   if (! S_ISREG (statbuf.st_mode))
16500     {
16501       error (_("'%s' is not an ordinary file\n"), file_name);
16502       return 1;
16503     }
16504
16505   file = fopen (file_name, "rb");
16506   if (file == NULL)
16507     {
16508       error (_("Input file '%s' is not readable.\n"), file_name);
16509       return 1;
16510     }
16511
16512   if (fread (armag, SARMAG, 1, file) != 1)
16513     {
16514       error (_("%s: Failed to read file's magic number\n"), file_name);
16515       fclose (file);
16516       return 1;
16517     }
16518
16519   current_file_size = (bfd_size_type) statbuf.st_size;
16520
16521   if (memcmp (armag, ARMAG, SARMAG) == 0)
16522     ret = process_archive (file_name, file, FALSE);
16523   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16524     ret = process_archive (file_name, file, TRUE);
16525   else
16526     {
16527       if (do_archive_index)
16528         error (_("File %s is not an archive so its index cannot be displayed.\n"),
16529                file_name);
16530
16531       rewind (file);
16532       archive_file_size = archive_file_offset = 0;
16533       ret = process_object (file_name, file);
16534     }
16535
16536   fclose (file);
16537
16538   current_file_size = 0;
16539   return ret;
16540 }
16541
16542 #ifdef SUPPORT_DISASSEMBLY
16543 /* Needed by the i386 disassembler.  For extra credit, someone could
16544    fix this so that we insert symbolic addresses here, esp for GOT/PLT
16545    symbols.  */
16546
16547 void
16548 print_address (unsigned int addr, FILE * outfile)
16549 {
16550   fprintf (outfile,"0x%8.8x", addr);
16551 }
16552
16553 /* Needed by the i386 disassembler.  */
16554 void
16555 db_task_printsym (unsigned int addr)
16556 {
16557   print_address (addr, stderr);
16558 }
16559 #endif
16560
16561 int
16562 main (int argc, char ** argv)
16563 {
16564   int err;
16565
16566 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16567   setlocale (LC_MESSAGES, "");
16568 #endif
16569 #if defined (HAVE_SETLOCALE)
16570   setlocale (LC_CTYPE, "");
16571 #endif
16572   bindtextdomain (PACKAGE, LOCALEDIR);
16573   textdomain (PACKAGE);
16574
16575   expandargv (&argc, &argv);
16576
16577   parse_args (argc, argv);
16578
16579   if (num_dump_sects > 0)
16580     {
16581       /* Make a copy of the dump_sects array.  */
16582       cmdline_dump_sects = (dump_type *)
16583           malloc (num_dump_sects * sizeof (* dump_sects));
16584       if (cmdline_dump_sects == NULL)
16585         error (_("Out of memory allocating dump request table.\n"));
16586       else
16587         {
16588           memcpy (cmdline_dump_sects, dump_sects,
16589                   num_dump_sects * sizeof (* dump_sects));
16590           num_cmdline_dump_sects = num_dump_sects;
16591         }
16592     }
16593
16594   if (optind < (argc - 1))
16595     show_name = 1;
16596   else if (optind >= argc)
16597     {
16598       warn (_("Nothing to do.\n"));
16599       usage (stderr);
16600     }
16601
16602   err = 0;
16603   while (optind < argc)
16604     err |= process_file (argv[optind++]);
16605
16606   if (dump_sects != NULL)
16607     free (dump_sects);
16608   if (cmdline_dump_sects != NULL)
16609     free (cmdline_dump_sects);
16610
16611   return err;
16612 }